@stemy/ngx-utils 13.1.3 → 13.2.0

package/fesm2015/stemy-ngx-utils.js

@@ -0,0 +1,4974 @@
+import { InjectionToken, TemplateRef, Injectable, Inject, PLATFORM_ID, Injector, NgZone, Optional, EventEmitter, isDevMode, ErrorHandler, Pipe, ChangeDetectorRef, Input, Output, HostBinding, HostListener, Directive, ElementRef, Renderer2, ViewContainerRef, Component, ContentChildren, ViewChild, ContentChild, APP_INITIALIZER, NgModule } from '@angular/core';
+import 'reflect-metadata';
+import { utc } from 'moment';
+import { first, skipWhile, mergeMap, timeout, map } from 'rxjs/operators';
+import { Subject, BehaviorSubject, Observable, Subscription, from, TimeoutError, combineLatest } from 'rxjs';
+import { Invokable } from 'invokable';
+import { __awaiter, __decorate } from 'tslib';
+import { ActivatedRouteSnapshot, NavigationEnd, Router, DefaultUrlSerializer, UrlTree, UrlSegmentGroup, UrlSegment, UrlSerializer } from '@angular/router';
+import { isPlatformBrowser, isPlatformServer, DOCUMENT, CommonModule } from '@angular/common';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { HttpClient, HttpHeaders, HttpParams, HttpUrlEncodingCodec, HttpHandler, HttpEventType } from '@angular/common/http';
+import { ɵangular_packages_platform_browser_platform_browser_g, DomSanitizer, EVENT_MANAGER_PLUGINS } from '@angular/platform-browser';
+import { addListener, removeListener } from 'resize-detector';
+import { FormsModule } from '@angular/forms';
+
+const defaultPredicate = () => true;
+const ɵ0 = defaultPredicate;
+const hasBlob = typeof Blob !== "undefined";
+const hasFile = typeof File !== "undefined";
+class ObjectUtils {
+    static compare(a, b) {
+        if ((a === null || b === null) || (typeof a != typeof b)) {
+            return null;
+        }
+        if (typeof a === "string") {
+            return (a).localeCompare(b);
+        }
+        else {
+            if (a instanceof Date) {
+                a = a.getTime();
+                b = b.getTime();
+            }
+            if (a > b) {
+                return 1;
+            }
+            else if (a < b) {
+                return -1;
+            }
+            return 0;
+        }
+    }
+    static getProperties(obj) {
+        if (!ObjectUtils.isObject(obj) && !ObjectUtils.isFunction(obj))
+            return [];
+        const props = new Set();
+        Object.keys(obj).forEach(p => props.add(p));
+        Object.getOwnPropertyNames(obj).forEach(p => props.add(p));
+        return Array.from(props);
+    }
+    static equals(a, b, visited = null) {
+        visited = visited || new Set();
+        if (visited.has(a) && visited.has(b))
+            return true;
+        if (a === b)
+            return true;
+        if (a === null || b === null)
+            return false;
+        if (a !== a && b !== b)
+            return true; // NaN === NaN
+        const at = typeof a, bt = typeof b;
+        let length, key, keySet;
+        if (at == bt && at == "object") {
+            visited.add(a);
+            visited.add(b);
+            if (Array.isArray(a)) {
+                if (!Array.isArray(b))
+                    return false;
+                if ((length = a.length) == b.length) {
+                    for (key = 0; key < length; key++) {
+                        if (!ObjectUtils.equals(a[key], b[key], visited))
+                            return false;
+                    }
+                    return true;
+                }
+            }
+            else {
+                if (Array.isArray(b)) {
+                    return false;
+                }
+                keySet = Object.create(null);
+                for (key in a) {
+                    if (a.hasOwnProperty(key)) {
+                        if (!ObjectUtils.equals(a[key], b[key], visited)) {
+                            return false;
+                        }
+                        keySet[key] = true;
+                    }
+                }
+                for (key in b) {
+                    if (b.hasOwnProperty(key) && !(key in keySet) && typeof b[key] !== "undefined") {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    static evaluate(expr, context = {}, res = {}) {
+        expr = Object.keys(context).reduce((res, key) => `var ${key} = this['${key}'];\n${res}`, expr);
+        const lines = expr.split("\n");
+        const lastLine = "return " + lines.pop().replace("return ", "");
+        lines.push(lastLine);
+        expr = lines.join("\n");
+        let result = null;
+        try {
+            result = new Function(expr).call(context);
+        }
+        catch (e) {
+            res.exception = e;
+            console.log(`Failed to parse expression: ${e.message}`, expr, context);
+        }
+        res.result = result;
+        return result;
+    }
+    static empty(obj) {
+        return !obj || Object.keys(obj).length == 0;
+    }
+    static iterate(obj, cb) {
+        if (!obj)
+            return;
+        const keys = Array.isArray(obj) ? Array.from(obj.keys()) : Object.keys(obj);
+        keys.forEach(
+        // @dynamic
+        key => {
+            cb(obj[key], key);
+        });
+    }
+    static getValue(obj, key, defaultValue, treeFallback = false) {
+        key = key || "";
+        const keys = key.split(".");
+        let curKey = "";
+        do {
+            curKey += keys.shift();
+            if (ObjectUtils.isDefined(obj) && ObjectUtils.isDefined(obj[curKey]) && (typeof obj[curKey] === "object" || !keys.length)) {
+                obj = obj[curKey];
+                curKey = "";
+            }
+            else if (!keys.length) {
+                defaultValue = typeof defaultValue == "undefined" ? key.replace(new RegExp(`${curKey}$`), `{${curKey}}`) : defaultValue;
+                obj = treeFallback ? obj || defaultValue : defaultValue;
+            }
+            else {
+                curKey += ".";
+            }
+        } while (keys.length);
+        return obj;
+    }
+    static mapToPath(target, source, path) {
+        if (typeof source === "undefined")
+            return target;
+        if (path.length == 0)
+            return source;
+        const key = path.shift();
+        if (key == "*") {
+            if (ObjectUtils.isArray(source)) {
+                target = ObjectUtils.isArray(target) ? target : [];
+                return source.map((item, index) => {
+                    return ObjectUtils.mapToPath(target[index], item, Array.from(path));
+                });
+            }
+            if (ObjectUtils.isObject(source)) {
+                target = ObjectUtils.isObject(target) ? target : {};
+                return Object.keys(source).reduce((result, key) => {
+                    result[key] = ObjectUtils.mapToPath(target[key], source[key], Array.from(path));
+                    return result;
+                }, {});
+            }
+            return ObjectUtils.isNullOrUndefined(target) ? null : target;
+        }
+        const isArray = ObjectUtils.isArray(target);
+        target = ObjectUtils.isObject(target) || isArray ? target : {};
+        target[key] = ObjectUtils.mapToPath(target[key], source, Array.from(path));
+        return isNaN(key) || isArray ? target : Object.values(target);
+    }
+    static filter(obj, predicate) {
+        return ObjectUtils.copyRecursive(null, obj, predicate, new Map());
+    }
+    static copy(obj) {
+        return ObjectUtils.copyRecursive(null, obj, null, new Map());
+    }
+    static assign(target, source, predicate) {
+        return ObjectUtils.copyRecursive(target, source, predicate, new Map());
+    }
+    static getType(obj) {
+        const regex = new RegExp("\\s([a-zA-Z]+)");
+        return Object.prototype.toString.call(obj).match(regex)[1].toLowerCase();
+    }
+    static isPrimitive(value) {
+        const type = typeof value;
+        return value == null || (type !== "object" && type !== "function");
+    }
+    static isObject(value) {
+        return ObjectUtils.getType(value) === "object";
+    }
+    static isDefined(value) {
+        return typeof value !== "undefined" && value !== null;
+    }
+    static isNullOrUndefined(value) {
+        return typeof value == "undefined" || value == null;
+    }
+    static isString(value) {
+        return typeof value === "string";
+    }
+    static isFunction(value) {
+        return typeof value === "function";
+    }
+    static isDate(value) {
+        return null !== value && !isNaN(value) && "undefined" !== typeof value.getDate;
+    }
+    static isBlob(value) {
+        return (hasBlob && value instanceof Blob) || (hasFile && value instanceof File);
+    }
+    static isBoolean(value) {
+        return typeof (value) == typeof (true);
+    }
+    static isNumber(value) {
+        if (typeof value !== "number")
+            return false;
+        const num = +value;
+        if ((num - num) !== 0) {
+            return false;
+        }
+        if (num === value) {
+            return true;
+        }
+    }
+    static isArray(value) {
+        return Array.isArray(value);
+    }
+    static isSet(value) {
+        return value instanceof Set;
+    }
+    static checkInterface(obj, interFaceObject) {
+        return ObjectUtils.isInterface(obj, interFaceObject);
+    }
+    static isInterface(obj, interFaceObject) {
+        if (!obj || typeof obj !== "object" || ObjectUtils.isArray(obj) || !ObjectUtils.isObject(interFaceObject))
+            return false;
+        const keys = Object.keys(interFaceObject);
+        for (const key of keys) {
+            let type = interFaceObject[key] || "";
+            if (type.startsWith("*")) {
+                type = type.substr(1);
+                if (obj.hasOwnProperty(key) && ObjectUtils.getType(obj[key]) !== type)
+                    return false;
+            }
+            else if (!obj.hasOwnProperty(key) || ObjectUtils.getType(obj[key]) !== type) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static pad(obj, width, chr = "0") {
+        const str = ObjectUtils.isDefined(obj) ? obj.toString() : "";
+        return str.length >= width ? str : new Array(width - str.length + 1).join(chr) + str;
+    }
+    static copyRecursive(target, source, predicate, copies) {
+        predicate = predicate || defaultPredicate;
+        if (ObjectUtils.isPrimitive(source) || ObjectUtils.isDate(source) || ObjectUtils.isBlob(source) || ObjectUtils.isFunction(source))
+            return source;
+        if (!copies.has(source)) {
+            if (ObjectUtils.isArray(source)) {
+                target = ObjectUtils.isArray(target) ? Array.from(target) : [];
+                copies.set(source, target);
+                source.forEach((item, index) => {
+                    if (!predicate(item, index, target, source))
+                        return;
+                    if (target.length > index)
+                        target[index] = ObjectUtils.copyRecursive(target[index], item, predicate, copies);
+                    else
+                        target.push(ObjectUtils.copyRecursive(null, item, predicate, copies));
+                });
+            }
+            else {
+                target = Object.assign({}, target);
+                copies.set(source, target);
+                Object.keys(source).forEach((key) => {
+                    if (!predicate(source[key], key, target, source))
+                        return;
+                    target[key] = ObjectUtils.copyRecursive(target[key], source[key], predicate, copies);
+                });
+            }
+        }
+        return copies.get(source);
+    }
+}
+
+class ReflectUtils {
+    static defineMetadata(key, data, target, name) {
+        Reflect.defineMetadata(key, data, target, name);
+    }
+    static getMetadata(key, target, name) {
+        return Reflect.getMetadata(key, target, name);
+    }
+    static getOwnMetadata(key, target, name) {
+        return Reflect.getOwnMetadata(key, target, name);
+    }
+    static resolve(obj, injector) {
+        if (!ObjectUtils.checkInterface(obj, { func: "function" }))
+            return obj;
+        const factory = obj;
+        let depends = [];
+        if (factory.type) {
+            const method = ObjectUtils.getProperties(factory.type).find(function (key) {
+                return factory.type[key] === factory.func;
+            });
+            depends = ReflectUtils.getMetadata("factoryDependencies", factory.type, method) || [];
+        }
+        else {
+            depends = ReflectUtils.getMetadata("factoryDependencies", factory.func) || [];
+        }
+        const parameters = depends.map(function (dep) {
+            return injector.get(dep);
+        }).concat(factory.params);
+        return factory.func.apply(null, parameters);
+    }
+}
+
+class CanvasColor {
+    constructor(r, g, b, a = 255) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+}
+const ICON_SERVICE = new InjectionToken("icon-service");
+const LANGUAGE_SERVICE = new InjectionToken("language-service");
+const AUTH_SERVICE = new InjectionToken("auth-service");
+// --- Storage Service ---
+var StorageMode;
+(function (StorageMode) {
+    StorageMode[StorageMode["Local"] = 0] = "Local";
+    StorageMode[StorageMode["Session"] = 1] = "Session";
+})(StorageMode || (StorageMode = {}));
+const TOASTER_SERVICE = new InjectionToken("toaster-service");
+const PROMISE_SERVICE = new InjectionToken("promise-service");
+// --- Unordered list ---
+class UnorederedListTemplate extends TemplateRef {
+}
+// --- Reflect utils ---
+function FactoryDependencies(...dependencies) {
+    return function (target, method) {
+        ReflectUtils.defineMetadata("factoryDependencies", dependencies, target, method);
+    };
+}
+class PaginationItemContext {
+    constructor(item, parallelItem, count, index, dataIndex) {
+        this.item = item;
+        this.parallelItem = parallelItem;
+        this.count = count;
+        this.index = index;
+        this.dataIndex = dataIndex;
+    }
+    get first() {
+        return this.index === 0;
+    }
+    get last() {
+        return this.index === this.count - 1;
+    }
+    get even() {
+        return this.index % 2 === 0;
+    }
+    get odd() {
+        return !this.even;
+    }
+    // Support for old dynamic table implementation
+    get row() {
+        console.log("DynamicTable row is deprecated use item instead");
+        return this.item;
+    }
+    // Support for old dynamic table implementation
+    get parallelRow() {
+        console.log("DynamicTable parallelRow is deprecated use parallelItem instead");
+        return this.parallelItem;
+    }
+    filter(filterRx) {
+        const keys = Object.keys(this.item);
+        for (const key of keys) {
+            const value = this.item[key];
+            if (ObjectUtils.isNullOrUndefined(value) || ObjectUtils.isObject(value))
+                continue;
+            const testValue = ObjectUtils.isString(value) ? value : value.toString();
+            if (testValue.match(filterRx))
+                return true;
+        }
+        return false;
+    }
+}
+class HttpPromise extends Promise {
+    constructor(rejectHandler, executor) {
+        super(executor);
+        this.rejectHandler = rejectHandler;
+        this.attachCount = 0;
+        this.runCount = 0;
+    }
+    then(onFulfilled, onRejected) {
+        this.attachCount++;
+        return super.then(value => {
+            this.runCount++;
+            return onFulfilled ? onFulfilled(value) : null;
+        }, (reason) => {
+            const result = onRejected ? onRejected(reason) : null;
+            this.hasRejectHandler = this.hasRejectHandler || (onRejected && result !== false);
+            this.runCount++;
+            this.rejectHandler(this.runCount == this.attachCount && !this.hasRejectHandler ? reason : null);
+            return result;
+        });
+    }
+    catch(onRejected) {
+        return this.then(null, onRejected);
+    }
+}
+const EXPRESS_REQUEST = new InjectionToken("express-request");
+const API_SERVICE = new InjectionToken("api-service");
+// --- Resource if ---
+class ResourceIfContext {
+}
+// --- ConfigService ---
+class IConfiguration {
+}
+const CONFIG_SERVICE = new InjectionToken("config-service");
+const BASE_CONFIG = new InjectionToken("base-config");
+const SCRIPT_PARAMS = new InjectionToken("script-params");
+const ROOT_ELEMENT = new InjectionToken("app-root-element");
+const ERROR_HANDLER = new InjectionToken("error-handler-callback");
+const GLOBAL_TEMPLATES = new InjectionToken("global-templates");
+// --- Valued promise ---
+class ValuedPromise extends Promise {
+}
+
+class AjaxRequestHandler {
+    constructor(pattern, callback) {
+        this.pattern = pattern;
+        this.callback = callback;
+        this.listener = (event) => {
+            const details = event.detail;
+            if (this.pattern.test(details.url))
+                this.callback(details, this.params);
+        };
+        this.params = {};
+        if (typeof XMLHttpRequest !== "undefined" && !AjaxRequestHandler.isOverridden) {
+            AjaxRequestHandler.isOverridden = true;
+            const originalOpen = XMLHttpRequest.prototype.open;
+            XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
+                originalOpen.apply(this, arguments);
+                window.dispatchEvent(new CustomEvent("ajaxRequest", {
+                    detail: {
+                        request: this,
+                        method: method,
+                        url: url
+                    }
+                }));
+            };
+        }
+    }
+    listen() {
+        if (typeof window === "undefined")
+            return this;
+        window.addEventListener("ajaxRequest", this.listener);
+        return this;
+    }
+    forget() {
+        if (typeof window === "undefined")
+            return;
+        window.removeEventListener("ajaxRequest", this.listener);
+        return this;
+    }
+}
+AjaxRequestHandler.isOverridden = false;
+
+class DateUtils {
+    static isHoliday(date) {
+        return utc(date).isoWeekday() > 5;
+    }
+    static isBusinessDay(date) {
+        return utc(date).isoWeekday() < 6;
+    }
+    static add(date, amount, unit) {
+        return utc(date).add(amount, unit).toDate();
+    }
+    static businessAdd(date, amount, unit) {
+        const signal = amount < 0 ? -1 : 1;
+        let remaining = Math.abs(amount);
+        let day = date;
+        while (remaining) {
+            day = DateUtils.add(day, signal, unit);
+            if (DateUtils.isBusinessDay(day)) {
+                remaining--;
+            }
+        }
+        return day;
+    }
+    static businessSubtract(date, amount, unit) {
+        return DateUtils.businessAdd(date, -amount, unit);
+    }
+}
+
+class BlurStack {
+    constructor() {
+        this.r = 0;
+        this.g = 0;
+        this.b = 0;
+        this.a = 0;
+        this.next = null;
+    }
+}
+const mul_table = [
+    512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512,
+    454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512,
+    482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456,
+    437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512,
+    497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328,
+    320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456,
+    446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335,
+    329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512,
+    505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405,
+    399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328,
+    324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271,
+    268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456,
+    451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388,
+    385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335,
+    332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292,
+    289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259
+];
+const shg_table = [
+    9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17,
+    17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19,
+    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24
+];
+class CanvasUtils {
+    static manipulatePixels(canvas, ctx, colorTransformer) {
+        const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const pixels = imgData.data;
+        for (let i = 0, n = pixels.length; i < n; i += 4) {
+            const clr = new CanvasColor(pixels[i], pixels[i + 1], pixels[i + 2], pixels[i + 3]);
+            const greyscale = clr.r * .3 + clr.g * .59 + clr.b * .11;
+            const color = colorTransformer(clr, greyscale);
+            pixels[i] = color.r;
+            pixels[i + 1] = color.g;
+            pixels[i + 2] = color.b;
+            pixels[i + 3] = color.a;
+        }
+        ctx.putImageData(imgData, 0, 0);
+    }
+    static thresholding(canvas, ctx, threshold = 50, colorTransformer) {
+        const min = new CanvasColor(0, 0, 0, 255);
+        const max = new CanvasColor(0, 0, 0, 0);
+        colorTransformer = ObjectUtils.isFunction(colorTransformer) ? colorTransformer : ((color, limit) => {
+            return limit ? max : min;
+        });
+        CanvasUtils.manipulatePixels(canvas, ctx, (color, greyscale) => {
+            return colorTransformer(color, greyscale > threshold, greyscale);
+        });
+    }
+    static stackBlur(canvas, ctx, radius = 10) {
+        if (isNaN(radius) || radius < 1)
+            return;
+        radius |= 0;
+        const top_x = 0;
+        const top_y = 0;
+        const width = canvas.width;
+        const height = canvas.height;
+        let imageData = null;
+        try {
+            try {
+                imageData = ctx.getImageData(top_x, top_y, width, height);
+            }
+            catch (e) {
+                // NOTE: this part is supposedly only needed if you want to work with local files
+                // so it might be okay to remove the whole try/catch block and just use
+                // imageData = ctx.getImageData( top_x, top_y, width, height );
+                try {
+                    netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
+                    imageData = ctx.getImageData(top_x, top_y, width, height);
+                }
+                catch (e) {
+                    alert("Cannot access local image");
+                    throw new Error("unable to access local image data: " + e);
+                }
+            }
+        }
+        catch (e) {
+            alert("Cannot access image");
+            throw new Error("unable to access image data: " + e);
+        }
+        const pixels = imageData.data;
+        let x, y, i, p, yp, yi, yw, r_sum, g_sum, b_sum, a_sum, r_out_sum, g_out_sum, b_out_sum, a_out_sum, r_in_sum, g_in_sum, b_in_sum, a_in_sum, pr, pg, pb, pa, rbs;
+        const div = radius + radius + 1;
+        const widthMinus1 = width - 1;
+        const heightMinus1 = height - 1;
+        const radiusPlus1 = radius + 1;
+        const sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;
+        const stackStart = new BlurStack();
+        let stackEnd = null;
+        let stack = stackStart;
+        for (i = 1; i < div; i++) {
+            stack = stack.next = new BlurStack();
+            if (i == radiusPlus1) {
+                stackEnd = stack;
+            }
+        }
+        stack.next = stackStart;
+        let stackIn = null;
+        let stackOut = null;
+        yw = yi = 0;
+        const mul_sum = mul_table[radius];
+        const shg_sum = shg_table[radius];
+        for (y = 0; y < height; y++) {
+            r_in_sum = g_in_sum = b_in_sum = a_in_sum = r_sum = g_sum = b_sum = a_sum = 0;
+            r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+            g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+            b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+            a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+            r_sum += sumFactor * pr;
+            g_sum += sumFactor * pg;
+            b_sum += sumFactor * pb;
+            a_sum += sumFactor * pa;
+            stack = stackStart;
+            for (i = 0; i < radiusPlus1; i++) {
+                stack.r = pr;
+                stack.g = pg;
+                stack.b = pb;
+                stack.a = pa;
+                stack = stack.next;
+            }
+            for (i = 1; i < radiusPlus1; i++) {
+                p = yi + ((widthMinus1 < i ? widthMinus1 : i) << 2);
+                r_sum += (stack.r = (pr = pixels[p])) * (rbs = radiusPlus1 - i);
+                g_sum += (stack.g = (pg = pixels[p + 1])) * rbs;
+                b_sum += (stack.b = (pb = pixels[p + 2])) * rbs;
+                a_sum += (stack.a = (pa = pixels[p + 3])) * rbs;
+                r_in_sum += pr;
+                g_in_sum += pg;
+                b_in_sum += pb;
+                a_in_sum += pa;
+                stack = stack.next;
+            }
+            stackIn = stackStart;
+            stackOut = stackEnd;
+            for (x = 0; x < width; x++) {
+                pixels[yi + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+                if (pa != 0) {
+                    pa = 255 / pa;
+                    pixels[yi] = ((r_sum * mul_sum) >> shg_sum) * pa;
+                    pixels[yi + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+                    pixels[yi + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+                }
+                else {
+                    pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;
+                }
+                r_sum -= r_out_sum;
+                g_sum -= g_out_sum;
+                b_sum -= b_out_sum;
+                a_sum -= a_out_sum;
+                r_out_sum -= stackIn.r;
+                g_out_sum -= stackIn.g;
+                b_out_sum -= stackIn.b;
+                a_out_sum -= stackIn.a;
+                p = (yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1)) << 2;
+                r_in_sum += (stackIn.r = pixels[p]);
+                g_in_sum += (stackIn.g = pixels[p + 1]);
+                b_in_sum += (stackIn.b = pixels[p + 2]);
+                a_in_sum += (stackIn.a = pixels[p + 3]);
+                r_sum += r_in_sum;
+                g_sum += g_in_sum;
+                b_sum += b_in_sum;
+                a_sum += a_in_sum;
+                stackIn = stackIn.next;
+                r_out_sum += (pr = stackOut.r);
+                g_out_sum += (pg = stackOut.g);
+                b_out_sum += (pb = stackOut.b);
+                a_out_sum += (pa = stackOut.a);
+                r_in_sum -= pr;
+                g_in_sum -= pg;
+                b_in_sum -= pb;
+                a_in_sum -= pa;
+                stackOut = stackOut.next;
+                yi += 4;
+            }
+            yw += width;
+        }
+        for (x = 0; x < width; x++) {
+            g_in_sum = b_in_sum = a_in_sum = r_in_sum = g_sum = b_sum = a_sum = r_sum = 0;
+            yi = x << 2;
+            r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+            g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+            b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+            a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+            r_sum += sumFactor * pr;
+            g_sum += sumFactor * pg;
+            b_sum += sumFactor * pb;
+            a_sum += sumFactor * pa;
+            stack = stackStart;
+            for (i = 0; i < radiusPlus1; i++) {
+                stack.r = pr;
+                stack.g = pg;
+                stack.b = pb;
+                stack.a = pa;
+                stack = stack.next;
+            }
+            yp = width;
+            for (i = 1; i <= radius; i++) {
+                yi = (yp + x) << 2;
+                r_sum += (stack.r = (pr = pixels[yi])) * (rbs = radiusPlus1 - i);
+                g_sum += (stack.g = (pg = pixels[yi + 1])) * rbs;
+                b_sum += (stack.b = (pb = pixels[yi + 2])) * rbs;
+                a_sum += (stack.a = (pa = pixels[yi + 3])) * rbs;
+                r_in_sum += pr;
+                g_in_sum += pg;
+                b_in_sum += pb;
+                a_in_sum += pa;
+                stack = stack.next;
+                if (i < heightMinus1) {
+                    yp += width;
+                }
+            }
+            yi = x;
+            stackIn = stackStart;
+            stackOut = stackEnd;
+            for (y = 0; y < height; y++) {
+                p = yi << 2;
+                pixels[p + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+                if (pa > 0) {
+                    pa = 255 / pa;
+                    pixels[p] = ((r_sum * mul_sum) >> shg_sum) * pa;
+                    pixels[p + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+                    pixels[p + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+                }
+                else {
+                    pixels[p] = pixels[p + 1] = pixels[p + 2] = 0;
+                }
+                r_sum -= r_out_sum;
+                g_sum -= g_out_sum;
+                b_sum -= b_out_sum;
+                a_sum -= a_out_sum;
+                r_out_sum -= stackIn.r;
+                g_out_sum -= stackIn.g;
+                b_out_sum -= stackIn.b;
+                a_out_sum -= stackIn.a;
+                p = (x + (((p = y + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width)) << 2;
+                r_sum += (r_in_sum += (stackIn.r = pixels[p]));
+                g_sum += (g_in_sum += (stackIn.g = pixels[p + 1]));
+                b_sum += (b_in_sum += (stackIn.b = pixels[p + 2]));
+                a_sum += (a_in_sum += (stackIn.a = pixels[p + 3]));
+                stackIn = stackIn.next;
+                r_out_sum += (pr = stackOut.r);
+                g_out_sum += (pg = stackOut.g);
+                b_out_sum += (pb = stackOut.b);
+                a_out_sum += (pa = stackOut.a);
+                r_in_sum -= pr;
+                g_in_sum -= pg;
+                b_in_sum -= pb;
+                a_in_sum -= pa;
+                stackOut = stackOut.next;
+                yi += width;
+            }
+        }
+        ctx.putImageData(imageData, top_x, top_y);
+    }
+    static measureTextFontSize(maxWidth, maxHeight, lines, font, lineHeightPercent = 1.1, canvas) {
+        const startSize = maxHeight;
+        const context = canvas.getContext("2d");
+        if (!canvas) {
+            canvas = document.createElement("canvas");
+            document.body.appendChild(canvas);
+        }
+        canvas.width = maxWidth + maxHeight;
+        canvas.height = maxHeight * 2;
+        let fontSize = CanvasUtils.halveValidateFontSize(startSize, (size) => {
+            CanvasUtils.setFontProps(context, font, size);
+            const maxTextLinesWidth = CanvasUtils.getTextWidth(context, lines);
+            return maxWidth - maxTextLinesWidth;
+        });
+        const bitmapHeight = CanvasUtils.getTextBitmapHeight(canvas, context, lines, font, fontSize, lineHeightPercent);
+        if (bitmapHeight > maxHeight) {
+            fontSize = CanvasUtils.halveValidateFontSize(fontSize, (size) => {
+                return maxHeight - CanvasUtils.getTextBitmapHeight(canvas, context, lines, font, size, lineHeightPercent);
+            });
+        }
+        return fontSize;
+    }
+    static drawLines(context, lines, font, size, lineHeightPercent = 1.1, align = "left", baseLine = "top", x = 0, y = 0) {
+        CanvasUtils.setFontProps(context, font, size, align, baseLine);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            context.fillText(line, x, y);
+            if (i < lines.length - 1) {
+                y += size * lineHeightPercent;
+            }
+        }
+        return y;
+    }
+    static wrapText(context, text, x, y, maxWidth) {
+        const words = text.split(" ");
+        const lineHeight = context.measureText("M").width * 1.3;
+        const lines = [];
+        let line = "";
+        for (let n = 0; n < words.length; n++) {
+            const testLine = line + words[n] + " ";
+            const metrics = context.measureText(testLine);
+            const testWidth = metrics.width;
+            if (testWidth > maxWidth && n > 0) {
+                lines.push(line);
+                line = words[n] + " ";
+            }
+            else {
+                line = testLine;
+            }
+        }
+        lines.push(line);
+        y -= lineHeight * .5 * lines.length;
+        lines.forEach(l => {
+            context.fillText(l, x, y);
+            y += lineHeight;
+        });
+    }
+    static setFontProps(context, font, fontSize, align = "left", baseLine = "top") {
+        context.font = `${fontSize}px ${font}`;
+        context.textAlign = align;
+        context.textBaseline = baseLine;
+    }
+    static getTextWidth(context, lines) {
+        let maxWidth = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            maxWidth = Math.max(maxWidth, context.measureText(line).width);
+        }
+        return maxWidth;
+    }
+    static getTextBitmapHeight(canvas, context, lines, font, fontSize, lineHeightPercent) {
+        const width = canvas.width;
+        const height = canvas.height;
+        context.clearRect(0, 0, width, height);
+        const textY = CanvasUtils.drawLines(context, lines, font, fontSize, lineHeightPercent, "left", "top", fontSize * .5, fontSize * .5);
+        const imageData = context.getImageData(0, 0, width, height);
+        let textHeight = 0;
+        yLoop: for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const index = (x + y * width) * 4;
+                if (imageData.data[index + 3] > 0) {
+                    textHeight = y + 1;
+                    continue yLoop;
+                }
+            }
+        }
+        return Math.max(textHeight, textY + fontSize);
+    }
+    static halveValidateFontSize(startSize, callback) {
+        let fontSize = startSize;
+        let lastFontSize = 0;
+        let direction;
+        for (let i = 0; i < 20; i++) {
+            direction = callback(fontSize);
+            const tempSize = fontSize;
+            if (direction < 0) {
+                fontSize = fontSize - (Math.abs(fontSize - lastFontSize) / 2);
+            }
+            else {
+                fontSize = fontSize + (Math.abs(fontSize - lastFontSize) / 2);
+            }
+            lastFontSize = tempSize;
+            if (Math.abs(fontSize - lastFontSize) < 0.1) {
+                break;
+            }
+        }
+        fontSize = Math.floor(fontSize);
+        return fontSize;
+    }
+}
+
+class FileUtils {
+    static getExtension(file) {
+        return file ? file.name.substr(file.name.lastIndexOf(".")).toLowerCase() : null;
+    }
+    static getName(file) {
+        return file ? file.name.substr(0, file.name.lastIndexOf(".")) : null;
+    }
+    static toFile(blob, fileName) {
+        const data = blob;
+        data.lastModifiedDate = new Date();
+        data.name = fileName.split(/\\|\//g).pop();
+        return data;
+    }
+    static dataToBlob(data) {
+        const parts = data.split(",");
+        const byteString = atob(parts[1]);
+        const mimeString = parts[0].split(":")[1].split(";")[0];
+        const ab = new ArrayBuffer(byteString.length);
+        const ia = new Uint8Array(ab);
+        for (let i = 0; i < byteString.length; i++) {
+            ia[i] = byteString.charCodeAt(i);
+        }
+        return new Blob([ab], { type: mimeString });
+    }
+    static saveBlob(blob, fileName) {
+        if (typeof saveAs == "undefined") {
+            throw Error("FileSaver library is not loaded. Please load it: https://www.npmjs.com/package/file-saver");
+        }
+        saveAs(blob, fileName);
+    }
+    static saveJson(json, fileName) {
+        if (!ObjectUtils.isObject(json))
+            return;
+        FileUtils.saveBlob(new Blob([JSON.stringify(json, null, 4)]), fileName);
+    }
+    static readFileAsText(file) {
+        return FileUtils.readFile(
+        // @dynamic
+        reader => reader.readAsText(file));
+    }
+    static readFileAsBinaryString(file) {
+        return FileUtils.readFile(
+        // @dynamic
+        reader => reader.readAsBinaryString(file));
+    }
+    static readFileAsDataURL(file) {
+        return FileUtils.readFile(
+        // @dynamic
+        reader => reader.readAsDataURL(file));
+    }
+    static readDataFromUrl(http, url) {
+        return new Promise(
+        // @dynamic
+        (resolve, reject) => {
+            if (!url) {
+                reject({
+                    message: "The url is not specified"
+                });
+                return;
+            }
+            if ((/^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/g).test(url)) {
+                resolve(url);
+                return;
+            }
+            first()(http.get(url, {
+                responseType: "blob"
+            })).subscribe((blob) => {
+                FileUtils.readFileAsDataURL(blob).then(resolve, reject);
+            }, reason => {
+                if (reason.status > 0)
+                    reject(reason);
+                else
+                    resolve(url);
+            });
+        });
+    }
+    static readFile(callback) {
+        return new Promise(
+        // @dynamic
+        (resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = (event) => resolve(event.target.result);
+            reader.onerror = reject;
+            callback(reader);
+        });
+    }
+}
+
+class GenericValue extends Subject {
+    constructor(value = null) {
+        super();
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        if (value == this._value)
+            return;
+        this._value = value;
+        this.next(value);
+    }
+    setJustValue(value) {
+        this._value = value;
+    }
+}
+
+class FileSystemEntry {
+    constructor(label, meta, image, data, parent, openCb) {
+        this.label = label;
+        this.meta = meta;
+        this.image = image;
+        this.data = data;
+        this.parent = parent;
+        this.openCb = openCb;
+        this.path = !parent ? [this] : parent.path.concat([this]);
+        this.level = this.path.length - 1;
+        this.classes = this.path
+            .filter(t => typeof t.data === "string" && t.data.length > 0).map(t => t.data)
+            .concat([`level-${this.level}`]);
+    }
+    open() {
+        this.result = this.result || this.openCb(this.data, this);
+        this.result.then(res => {
+            if (Array.isArray(res))
+                return;
+            this.result = null;
+        });
+        return this.result;
+    }
+}
+
+class Rect {
+    constructor(x, y, width, height, rotation = 0) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.rotation = rotation;
+    }
+    get center() {
+        return new Point(this.x, this.y);
+    }
+    get left() {
+        return this.x - this.width * .5;
+    }
+    get right() {
+        return this.x + this.width * .5;
+    }
+    get bottom() {
+        return this.y - this.height * .5;
+    }
+    get top() {
+        return this.y + this.height * .5;
+    }
+    distance(p) {
+        p = p.rotateAround(this.center, -this.rotation);
+        const x = Math.max(this.left - p.x, 0, p.x - this.right);
+        const y = Math.max(this.bottom - p.y, 0, p.y - this.top);
+        return Math.sqrt(x * x + y * y);
+    }
+}
+class Circle {
+    constructor(x, y, radius) {
+        this.x = x;
+        this.y = y;
+        this.radius = radius;
+    }
+    get center() {
+        return new Point(this.x, this.y);
+    }
+    get left() {
+        return new Point(this.x - this.radius, this.y);
+    }
+    get right() {
+        return new Point(this.x + this.radius, this.y);
+    }
+    get top() {
+        return new Point(this.x, this.y + this.radius);
+    }
+    get bottom() {
+        return new Point(this.x, this.y - this.radius);
+    }
+    get rect() {
+        return new Rect(this.x, this.y, this.radius * 2, this.radius * 2);
+    }
+    distance(p) {
+        return this.center.distance(p) - this.radius;
+    }
+}
+class Point {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    get length() {
+        return this.distance(Point.Zero);
+    }
+    get perpendicular() {
+        return new Point(this.y, -this.x);
+    }
+    add(p) {
+        return new Point(this.x + p.x, this.y + p.y);
+    }
+    subtract(p) {
+        return new Point(this.x - p.x, this.y - p.y);
+    }
+    multiply(p) {
+        if (p instanceof Point) {
+            return new Point(this.x * p.x, this.y * p.y);
+        }
+        return new Point(this.x * p, this.y * p);
+    }
+    distance(b) {
+        const x = b.x - this.x;
+        const y = b.y - this.y;
+        return Math.sqrt(x * x + y * y);
+    }
+    lerp(p, ratio) {
+        const diff = p.subtract(this);
+        return this.add(diff.multiply(ratio));
+    }
+    perpendicularTo(p, length) {
+        const diff = p.perpendicular.subtract(this.perpendicular);
+        const ratio = length / diff.length;
+        const center = this.lerp(p, .5);
+        return center.add(diff.multiply(ratio));
+    }
+    circleWith(a, b) {
+        const yDelta_a = b.y - a.y;
+        const xDelta_a = b.x - a.x;
+        const yDelta_b = this.y - b.y;
+        const xDelta_b = this.x - b.x;
+        const aSlope = yDelta_a / xDelta_a;
+        const bSlope = yDelta_b / xDelta_b;
+        const x = (aSlope * bSlope * (a.y - this.y) + bSlope * (a.x + b.x) - aSlope * (b.x + this.x)) / (2 * (bSlope - aSlope));
+        const y = -1 * (x - (a.x + b.x) / 2) / aSlope + (a.y + b.y) / 2;
+        const center = new Point(x, y);
+        return new Circle(center.x, center.y, center.distance(this));
+    }
+    tangents(c) {
+        const pd = c.center.subtract(this);
+        const a = Math.asin(c.radius / pd.length);
+        const b = Math.atan2(pd.y, pd.x);
+        // Tangent points
+        let t = b - a;
+        const t1 = new Point(c.x + c.radius * Math.sin(t), c.y + c.radius * -Math.cos(t));
+        t = b + a;
+        const t2 = new Point(c.x + c.radius * -Math.sin(t), c.y + c.radius * Math.cos(t));
+        return [t1, t2];
+    }
+    angle(p) {
+        const diff = p.subtract(this);
+        return Math.atan2(diff.y, diff.x) * 180 / Math.PI;
+    }
+    rotateAround(p, angle) {
+        const rotation = (p.angle(this) + angle) * Math.PI / 180;
+        const distance = p.distance(this);
+        const rotated = new Point(Math.cos(rotation) * distance, Math.sin(rotation) * distance);
+        return p.add(rotated);
+    }
+}
+Point.Zero = new Point(0, 0);
+
+class Initializer {
+    constructor(callback, shouldInit = true) {
+        this.callback = callback;
+        this.shouldInit = shouldInit;
+        this.initialized = !this.shouldInit;
+        // @ts-ignore
+        return Invokable.create(this);
+    }
+    get isInitialized() {
+        return this.initialized;
+    }
+    [Invokable.call]() {
+        if (this.initialized)
+            return null;
+        this.initialized = true;
+        return this.callback();
+    }
+}
+
+class LoaderUtils {
+    static loadScript(src, async = false) {
+        this.scriptPromises[src] = this.scriptPromises[src] || new Promise((resolve, reject) => {
+            // Load script
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+            script.src = src;
+            script.async = async;
+            if (script.readyState) {
+                // Internet explorer
+                script.onreadystatechange = () => {
+                    if (script.readyState === "loaded" || script.readyState === "complete") {
+                        script.onreadystatechange = null;
+                        resolve(script);
+                    }
+                };
+            }
+            else {
+                // Other browsers
+                script.onload = () => resolve(script);
+            }
+            script.onerror = (error) => reject(error);
+            document.body.appendChild(script);
+        });
+        return this.scriptPromises[src];
+    }
+    static loadStyle(src) {
+        this.stylePromises[src] = this.stylePromises[src] || new Promise((resolve, reject) => {
+            // Load script
+            const link = document.createElement("link");
+            link.rel = "stylesheet";
+            link.type = "text/css";
+            link.href = src;
+            if (link.readyState) {
+                // Internet explorer
+                link.onreadystatechange = () => {
+                    if (link.readyState === "loaded" || link.readyState === "complete") {
+                        link.onreadystatechange = null;
+                        resolve(link);
+                    }
+                };
+            }
+            else {
+                // Other browsers
+                link.onload = () => resolve(link);
+            }
+            link.onerror = (error) => reject(error);
+            document.body.appendChild(link);
+        });
+        return this.stylePromises[src];
+    }
+}
+LoaderUtils.scriptPromises = {};
+LoaderUtils.stylePromises = {};
+
+class MathUtils {
+    static equal(a, b, epsilon = null) {
+        epsilon = ObjectUtils.isNumber(epsilon) ? epsilon : MathUtils.EPSILON;
+        return Math.abs(a - b) < epsilon;
+    }
+    static clamp(value, min, max) {
+        return Math.max(Math.min(value, max), min);
+    }
+    static round(value, precision = 2, divider = 1) {
+        precision = Math.pow(10, precision);
+        return Math.round(value * precision / divider) / precision;
+    }
+    static approxIndex(x, values, epsilon = null) {
+        if (!Array.isArray(values) || values.length == 0) {
+            return -1;
+        }
+        let s = 0;
+        let e = values.length - 1;
+        while (s <= e) {
+            const i = Math.floor((s + e) / 2);
+            const v = values[i];
+            if (MathUtils.equal(v, x, epsilon)) {
+                return i;
+            }
+            if (v < x) {
+                s = i + 1;
+            }
+            else {
+                e = i - 1;
+            }
+        }
+        const m = Math.max(e, 0);
+        const a = values[s];
+        const b = values[m];
+        return Math.abs(a - x) < Math.abs(b - x) ? s : m;
+    }
+    static approximate(x, values, epsilon = null) {
+        var _a;
+        const index = MathUtils.approxIndex(x, values, epsilon);
+        return (_a = values[index]) !== null && _a !== void 0 ? _a : null;
+    }
+}
+MathUtils.EPSILON = 1e-9;
+
+/**
+ * Use this service to determine which is the current environment
+ */
+class UniversalService {
+    constructor(platformId, dds) {
+        this.platformId = platformId;
+        this.dds = dds;
+        const info = this.dds.getDeviceInfo();
+        this.crawler = /(bot|google|baidu|bing|msn|duckduckbot|teoma|slurp|yandex|lighthouse|angular-universal|PTST)/gi.test(info.userAgent);
+    }
+    get isBrowser() {
+        return isPlatformBrowser(this.platformId);
+    }
+    get isServer() {
+        return isPlatformServer(this.platformId);
+    }
+    get deviceInfo() {
+        return this.isServer
+            ? {
+                userAgent: "angular-universal",
+                os: "unknown",
+                browser: "node",
+                device: "node",
+                os_version: "unknown",
+                browser_version: "unknown",
+                deviceType: "unknown",
+                orientation: "landscape"
+            }
+            : this.dds.getDeviceInfo();
+    }
+    get browserName() {
+        return this.dds.browser;
+    }
+    get browserVersion() {
+        return this.dds.browser_version;
+    }
+    get isExplorer() {
+        return this.dds.browser == "ie";
+    }
+    get isEdge() {
+        return this.dds.browser == "ms-edge";
+    }
+    get isChrome() {
+        return this.dds.browser == "chrome";
+    }
+    get isFirefox() {
+        return this.dds.browser == "firefox";
+    }
+    get isSafari() {
+        return this.dds.browser == "safari";
+    }
+    get isTablet() {
+        return this.dds.isTablet();
+    }
+    get isMobile() {
+        return this.dds.isMobile();
+    }
+    get isDesktop() {
+        return this.dds.isDesktop();
+    }
+    get isCrawler() {
+        return this.crawler;
+    }
+}
+UniversalService.decorators = [
+    { type: Injectable }
+];
+UniversalService.ctorParameters = () => [
+    { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] },
+    { type: DeviceDetectorService }
+];
+
+const emptySnapshot = new ActivatedRouteSnapshot();
+const emptyData = { id: "" };
+const emptyParams = {};
+const emptySegments = [];
+const emptyComponents = [];
+class StateService extends BehaviorSubject {
+    constructor(injector, zone, universal, router = null) {
+        super(null);
+        this.injector = injector;
+        this.zone = zone;
+        this.universal = universal;
+        this.router = router;
+        this.handleRouterEvent = (event) => {
+            if (!(event instanceof NavigationEnd))
+                return;
+            const routerStateSnapshot = this.router.routerState.snapshot;
+            let snapshot = routerStateSnapshot.root;
+            let context = this.contexts.getContext("primary");
+            let segments = snapshot.url;
+            const components = [];
+            const snapshots = [];
+            while (snapshot) {
+                snapshots.push(snapshot);
+                segments = segments.concat(snapshot.url);
+                if (context) {
+                    if (context.outlet && context.outlet.isActivated)
+                        components.push(context.outlet.component);
+                    context = context.children.getContext("primary");
+                }
+                snapshot = snapshot.firstChild;
+            }
+            this.comp = components[components.length - 1];
+            this.shot = snapshots[snapshots.length - 1];
+            this.stateInfo = {
+                url: routerStateSnapshot.url,
+                segments: segments,
+                components: components
+            };
+            this.next(this.shot);
+        };
+        if (!this.router)
+            return;
+        this.globalExtras = {
+            queryParamsHandling: "merge"
+        };
+        this.router.events.subscribe(this.handleRouterEvent);
+        this.stateInfo = {
+            url: "",
+            segments: [],
+            components: []
+        };
+        this.contexts = router.rootContexts;
+    }
+    static toPath(route, params) {
+        let path = route.path || "";
+        ObjectUtils.iterate(params, (value, key) => {
+            path = path.replace(`:${key}`, `${value}`);
+        });
+        return path;
+    }
+    get component() {
+        return this.comp;
+    }
+    get snapshot() {
+        return this.shot || emptySnapshot;
+    }
+    get route() {
+        return this.snapshot.routeConfig;
+    }
+    get data() {
+        return this.snapshot.data || emptyData;
+    }
+    get params() {
+        return this.snapshot.params || emptyParams;
+    }
+    get queryParams() {
+        return this.snapshot.queryParams || emptyParams;
+    }
+    get url() {
+        return this.stateInfo.url || "";
+    }
+    get urlSegments() {
+        return this.stateInfo.segments || emptySegments;
+    }
+    get components() {
+        return this.stateInfo.components || emptyComponents;
+    }
+    get routerConfig() {
+        return this.router.config;
+    }
+    reload() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routerStateSnapshot = this.router.routerState.snapshot;
+            const resolvers = this.route.resolve || {};
+            const keys = Object.keys(resolvers);
+            for (const key of keys) {
+                const resolver = this.injector.get(resolvers[key]);
+                let resolved = resolver.resolve(this.snapshot, routerStateSnapshot);
+                if (resolved instanceof Observable) {
+                    resolved = resolved.toPromise();
+                }
+                if (resolved instanceof Promise) {
+                    resolved = yield resolved;
+                }
+                this.data[key] = resolved;
+            }
+        });
+    }
+    navigateByUrl(url, navigationExtras = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.navigate(url, navigationExtras);
+        });
+    }
+    navigate(url, navigationExtras = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.router)
+                return false;
+            const [tree, extras] = this.createUrlTree(url, navigationExtras);
+            return this.zone.run(() => {
+                return this.router.navigateByUrl(tree, extras);
+            });
+        });
+    }
+    open(url, target = "_blank", navigationExtras = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.router)
+                return false;
+            const [tree, extras] = this.createUrlTree(url, navigationExtras);
+            return this.zone.run(() => {
+                return this.openInNewWindow(tree, target) || this.router.navigateByUrl(tree, extras);
+            });
+        });
+    }
+    subscribeImmediately(next, error, complete) {
+        return this.pipe(skipWhile(v => v == null)).subscribe(next, error, complete);
+    }
+    openInNewWindow(tree, target) {
+        if (!this.universal.isBrowser)
+            return false;
+        const baseUrl = window.location.href.replace(this.router.url, "");
+        try {
+            const serialized = this.router.serializeUrl(tree);
+            const separator = serialized.startsWith("/") ? "" : "/";
+            window.open(baseUrl + separator + serialized, target);
+            return true;
+        }
+        catch (e) {
+            console.log(`Can't open new window: ${e}`);
+            return false;
+        }
+    }
+    createUrlTree(url, extras) {
+        if (!this.router)
+            return null;
+        extras = Object.assign(extras, this.globalExtras, extras || {});
+        if (ObjectUtils.isArray(url)) {
+            return [this.router.createUrlTree(url, extras), extras];
+        }
+        if (ObjectUtils.isString(url)) {
+            return [this.router.parseUrl(url), extras];
+        }
+        return [url, extras];
+    }
+}
+StateService.decorators = [
+    { type: Injectable }
+];
+StateService.ctorParameters = () => [
+    { type: Injector },
+    { type: NgZone },
+    { type: UniversalService },
+    { type: Router, decorators: [{ type: Optional }] }
+];
+
+class AuthGuard {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+    }
+    static guardAuthenticated(auth) {
+        return Promise.resolve(auth.isAuthenticated);
+    }
+    static guardNotAuthenticated(auth) {
+        return Promise.resolve(!auth.isAuthenticated);
+    }
+    static guardNothing() {
+        return Promise.resolve(true);
+    }
+    static guardAuthField(auth, expression = `auth.isAuthenticated`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { auth }));
+        };
+        return lambda;
+    }
+    static guardStateField(state, expression = `state.data`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { state }));
+        };
+        return lambda;
+    }
+    static guardAuthStateField(auth, state, expression = `auth.isAuthenticated`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { auth, state }));
+        };
+        return lambda;
+    }
+    static wildRouteMatch(segments) {
+        return { consumed: segments };
+    }
+    static noRouteMatch() {
+        return null;
+    }
+    checkRouteMenu(route) {
+        if (!route.data || !route.data.name)
+            return Promise.resolve(false);
+        return this.checkRoute(route);
+    }
+    checkRoute(route, next) {
+        const routeData = route.data || {};
+        if (!routeData.guards)
+            return Promise.resolve(!route.canActivate || this.auth.isAuthenticated);
+        return new Promise(resolve => {
+            const guards = routeData.guards.map(g => {
+                const guard = ReflectUtils.resolve(g, this.injector);
+                return guard(this.auth, route, next);
+            });
+            Promise.all(guards).then(results => {
+                resolve(results.indexOf(false) < 0);
+            });
+        });
+    }
+    canActivate(next, state) {
+        const route = next.routeConfig;
+        return new Promise(resolve => {
+            this.auth.checkAuthenticated().then(() => {
+                this.checkRoute(route, next).then(hasRights => {
+                    resolve(hasRights);
+                    if (!hasRights) {
+                        this.getReturnState(route).then(returnState => {
+                            if (!returnState)
+                                return;
+                            this.state.navigate(returnState, { queryParams: next.queryParams });
+                        });
+                    }
+                });
+            });
+        });
+    }
+    getConfig(route, config, path) {
+        if (!config)
+            return null;
+        const match = config.findIndex(t => t == route);
+        if (match >= 0)
+            return config;
+        for (const subConfig of config) {
+            if (subConfig.path)
+                path.push(subConfig.path);
+            const loadedChildren = (subConfig["_loadedConfig"] || { routes: null }).routes;
+            const match = this.getConfig(route, subConfig.children || loadedChildren, path);
+            if (!match) {
+                if (subConfig.path)
+                    path.length -= 1;
+                continue;
+            }
+            return match;
+        }
+        return null;
+    }
+    getReturnState(route) {
+        if (!route)
+            return Promise.resolve(null);
+        if (ObjectUtils.isObject(route.data) && ObjectUtils.isArray(route.data.returnState)) {
+            return Promise.resolve(route.data.returnState);
+        }
+        const path = [];
+        const config = this.getConfig(route, this.state.routerConfig, path);
+        return new Promise(resolve => {
+            this.getReturnStateRecursive(config).then(rs => {
+                if (!ObjectUtils.isArray(rs)) {
+                    resolve(rs);
+                    return;
+                }
+                resolve(path.concat(rs));
+            });
+        });
+    }
+    getReturnStateRecursive(config, c = 0) {
+        if (!config || c >= config.length)
+            return Promise.resolve(null);
+        return new Promise(resolve => {
+            const route = config[c];
+            const check = !route.component ? Promise.resolve(false) : this.checkRoute(route);
+            check.then(res => {
+                if (res) {
+                    resolve([route.path]);
+                    return;
+                }
+                this.getReturnStateRecursive(config, c + 1).then(resolve);
+            });
+        });
+    }
+}
+AuthGuard.decorators = [
+    { type: Injectable }
+];
+AuthGuard.ctorParameters = () => [
+    { type: Injector, decorators: [{ type: Inject, args: [Injector,] }] },
+    { type: StateService, decorators: [{ type: Inject, args: [StateService,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [AUTH_SERVICE,] }] }
+];
+__decorate([
+    FactoryDependencies(AUTH_SERVICE)
+], AuthGuard, "guardAuthField", null);
+__decorate([
+    FactoryDependencies(StateService)
+], AuthGuard, "guardStateField", null);
+__decorate([
+    FactoryDependencies(AUTH_SERVICE, StateService)
+], AuthGuard, "guardAuthStateField", null);
+
+class TimerUtils {
+    static createTimeout(func, time) {
+        // @dynamic
+        const run = (timer) => {
+            timer.clear();
+            timer.id = setTimeout(() => {
+                timer.id = null;
+                timer.func();
+            }, timer.time);
+        };
+        // @dynamic
+        const clear = (timer) => {
+            if (!timer.id)
+                return;
+            clearTimeout(timer.id);
+            timer.id = null;
+        };
+        return TimerUtils.createTimer(run, clear, func, time);
+    }
+    static createInterval(func, time) {
+        // @dynamic
+        const run = (timer) => {
+            timer.clear();
+            timer.id = setInterval(timer.func, timer.time);
+        };
+        // @dynamic
+        const clear = (timer) => {
+            if (!timer.id)
+                return;
+            clearInterval(timer.id);
+            timer.id = null;
+        };
+        return TimerUtils.createTimer(run, clear, func, time);
+    }
+    static createTimer(run, clear, func, time) {
+        const timer = {};
+        const setParams = (func, time) => {
+            timer.func = !ObjectUtils.isFunction(func) ? (() => { }) : func;
+            timer.time = !ObjectUtils.isNumber(time) ? 100 : time;
+        };
+        timer.run = () => run(timer);
+        timer.clear = () => clear(timer);
+        timer.set = (func, time) => {
+            setParams(func, time);
+            timer.run();
+        };
+        setParams(func, time);
+        return timer;
+    }
+}
+
+class ObservableUtils {
+    static toSearch(search) {
+        return mergeMap(
+        // @dynamic
+        (token) => search.getSearchResults(token))(Observable.create(
+        // @dynamic
+        (observer) => {
+            observer.next(search.search);
+        }));
+    }
+    static multiSubscription(...subscriptions) {
+        // @dynamic
+        const lambda = () => {
+            subscriptions.forEach(s => {
+                s.unsubscribe();
+            });
+        };
+        return new Subscription(lambda);
+    }
+    static subscribe(...subscribers) {
+        const subscriptions = [];
+        subscribers.forEach(info => {
+            let alreadyCalled = false;
+            const timer = info.timeout > 0 ? TimerUtils.createTimeout() : 0;
+            const cb = timer ? function () {
+                const args = Array.from(arguments);
+                timer.set(() => {
+                    info.cb.apply(null, args);
+                }, info.timeout);
+            } : info.cb;
+            info.subjects.forEach(subject => {
+                const ss = subject.subscribe((value) => {
+                    alreadyCalled = true;
+                    cb.call(null, subject, value);
+                });
+                subscriptions.push(ss);
+            });
+            if (alreadyCalled)
+                return;
+            cb();
+        });
+        return ObservableUtils.multiSubscription(...subscriptions);
+    }
+    static fromFunction(callbackFunc) {
+        let subject;
+        return new Observable((subscriber) => {
+            if (!subject) {
+                subject = new Subject();
+                try {
+                    subject = from(callbackFunc());
+                }
+                catch (err) {
+                    subject.error(err);
+                }
+            }
+            return subject.subscribe(subscriber);
+        });
+    }
+}
+
+class StringUtils {
+    static concat(separator, ...strings) {
+        return strings.filter(
+        // @dynamic
+        str => !!str).join(separator);
+    }
+    static startsWith(str, ...starts) {
+        for (let i = 0; i < starts.length; i++) {
+            if (str.startsWith(starts[i]))
+                return true;
+        }
+        return false;
+    }
+    static has(str, ...parts) {
+        for (let i = 0; i < parts.length; i++) {
+            if (str.indexOf(parts[i]) >= 0)
+                return true;
+        }
+        return false;
+    }
+    static lcFirst(str) {
+        return str ? str.charAt(0).toLowerCase() + str.substring(1) : "";
+    }
+    static ucFirst(str) {
+        return str ? str.charAt(0).toUpperCase() + str.substring(1) : "";
+    }
+}
+
+class ArrayUtils {
+    static has(arr, ...items) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isArray(items))
+            return false;
+        for (let i = 0; i < items.length; i++) {
+            if (arr.indexOf(items[i]) >= 0)
+                return true;
+        }
+        return false;
+    }
+    static match(arr, str) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isString(str))
+            return false;
+        for (let i = 0; i < arr.length; i++) {
+            if (arr[i] instanceof RegExp) {
+                const regex = arr[i];
+                if (regex.test(str))
+                    return true;
+            }
+        }
+        return false;
+    }
+    static any(arr, cb) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isFunction(cb))
+            return false;
+        for (let i = 0; i < arr.length; i++) {
+            if (cb(arr[i]))
+                return true;
+        }
+        return false;
+    }
+    static move(arr, oldIndex, newIndex) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        const length = arr.length;
+        while (oldIndex < 0) {
+            oldIndex += length;
+        }
+        while (newIndex < 0) {
+            newIndex += length;
+        }
+        if (newIndex >= length) {
+            let k = newIndex - length + 1;
+            while (k--) {
+                arr.push(undefined);
+            }
+        }
+        arr.splice(newIndex, 0, arr.splice(oldIndex, 1)[0]);
+        return arr;
+    }
+    static reversed(arr) {
+        const result = [];
+        if (!ObjectUtils.isArray(arr))
+            return result;
+        for (let i = arr.length - 1; i >= 0; i--) {
+            result.push(arr[i]);
+        }
+        return result;
+    }
+    static min(arr, cb) {
+        if (!ObjectUtils.isArray(arr))
+            return null;
+        let min = Number.MAX_SAFE_INTEGER;
+        let result = null;
+        for (let i = 0; i < arr.length; i++) {
+            const current = cb(arr[i], i);
+            if (current < min || result === null) {
+                min = current;
+                result = arr[i];
+            }
+        }
+        return result;
+    }
+    static max(arr, cb) {
+        if (!ObjectUtils.isArray(arr))
+            return null;
+        let max = Number.MIN_SAFE_INTEGER;
+        let result = null;
+        for (let i = 0; i < arr.length; i++) {
+            const current = cb(arr[i], i);
+            if (current > max || result === null) {
+                max = current;
+                result = arr[i];
+            }
+        }
+        return result;
+    }
+    static chunk(arr, size) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        size = Math.max(1, size);
+        const result = [];
+        for (let i = 0; i < arr.length; i += size) {
+            result.push(arr.slice(i, i + size));
+        }
+        return result;
+    }
+    static unique(arr) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        return arr.filter((value, index, self) => {
+            return self.indexOf(value) === index;
+        });
+    }
+}
+
+class SetUtils {
+    static equals(set, obj) {
+        if (!ObjectUtils.isSet(set) || !ObjectUtils.isSet(obj))
+            return false;
+        if (set.size != obj.size)
+            return false;
+        for (const item in set) {
+            if (!obj.has(item))
+                return false;
+        }
+        return true;
+    }
+    static addArray(set, items) {
+        if (!ObjectUtils.isSet(set) || !ObjectUtils.isArray(items))
+            return;
+        items.forEach(i => set.add(i));
+    }
+}
+
+class UniqueUtils {
+    static uuid() {
+        if (typeof window !== "undefined" && typeof window.crypto !== "undefined" && typeof window.crypto.getRandomValues !== "undefined") {
+            const buf = new Uint16Array(8);
+            window.crypto.getRandomValues(buf);
+            return (this.pad4(buf[0]) + this.pad4(buf[1]) + "-" + this.pad4(buf[2]) + "-" + this.pad4(buf[3]) + "-" + this.pad4(buf[4]) + "-" + this.pad4(buf[5]) + this.pad4(buf[6]) + this.pad4(buf[7]));
+        }
+        return this.random4() + this.random4() + "-" + this.random4() + "-" + this.random4() + "-" +
+            this.random4() + "-" + this.random4() + this.random4() + this.random4();
+    }
+    static pad4(num) {
+        let ret = num.toString(16);
+        while (ret.length < 4) {
+            ret = "0" + ret;
+        }
+        return ret;
+    }
+    static random4() {
+        return Math.floor((1 + Math.random()) * 0x10000)
+            .toString(16)
+            .substring(1);
+    }
+}
+
+class Vector {
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    get negative() {
+        return new Vector(-this.x, -this.y, -this.z);
+    }
+    get length() {
+        return Math.sqrt(this.dot(this));
+    }
+    get unit() {
+        return this.divide(this.length);
+    }
+    get min() {
+        return Math.min(Math.min(this.x, this.y), this.z);
+    }
+    get max() {
+        return Math.max(Math.max(this.x, this.y), this.z);
+    }
+    get angles() {
+        return {
+            theta: Math.atan2(this.z, this.x),
+            phi: Math.asin(this.y / this.length)
+        };
+    }
+    add(v) {
+        if (v instanceof Vector)
+            return new Vector(this.x + v.x, this.y + v.y, this.z + v.z);
+        else
+            return new Vector(this.x + v, this.y + v, this.z + v);
+    }
+    subtract(v) {
+        if (v instanceof Vector)
+            return new Vector(this.x - v.x, this.y - v.y, this.z - v.z);
+        else
+            return new Vector(this.x - v, this.y - v, this.z - v);
+    }
+    multiply(v) {
+        if (v instanceof Vector)
+            return new Vector(this.x * v.x, this.y * v.y, this.z * v.z);
+        else
+            return new Vector(this.x * v, this.y * v, this.z * v);
+    }
+    divide(v) {
+        if (v instanceof Vector)
+            return new Vector(this.x / v.x, this.y / v.y, this.z / v.z);
+        else
+            return new Vector(this.x / v, this.y / v, this.z / v);
+    }
+    equals(v) {
+        return this.x == v.x && this.y == v.y && this.z == v.z;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+    cross(v) {
+        return new Vector(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x);
+    }
+    angleTo(v) {
+        return Math.acos(this.dot(v) / (this.length * v.length));
+    }
+    toArray(n) {
+        return [this.x, this.y, this.z].slice(0, n || 3);
+    }
+    clone() {
+        return new Vector(this.x, this.y, this.z);
+    }
+    init(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+}
+
+const emptyGuards = [];
+class AclService {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+        this.components = [];
+        this.auth.userChanged.subscribe(() => {
+            this.components.forEach(t => t.dirty = true);
+            const info = this.getStateInfo();
+            const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
+            check.then(result => {
+                if (result) {
+                    if (!info || !info.dirty)
+                        return;
+                    info.dirty = false;
+                    const component = info.component;
+                    if (!info.component)
+                        return;
+                    if (info.first) {
+                        if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                            component.onUserInitialized();
+                        }
+                        info.first = false;
+                        return;
+                    }
+                    if (ObjectUtils.isFunction(component.onUserChanged)) {
+                        component.onUserChanged();
+                    }
+                    return;
+                }
+                info.guard.getReturnState(info.route).then(returnState => {
+                    if (!returnState)
+                        return;
+                    this.state.navigate(returnState);
+                });
+            });
+        });
+        this.state.subscribe(() => {
+            const info = this.getStateInfo();
+            if (!(info === null || info === void 0 ? void 0 : info.component))
+                return;
+            const component = info.component;
+            if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                component.onUserInitialized();
+            }
+        });
+    }
+    getStateInfo() {
+        const route = this.state.route;
+        if (!route)
+            return null;
+        let info = this.components.find(t => t.route == this.state.route);
+        if (!info) {
+            const guardType = (route.canActivate || emptyGuards)[0];
+            info = {
+                route: this.state.route,
+                guard: guardType ? this.injector.get(guardType) : null,
+                dirty: true,
+                first: true
+            };
+            this.components.push(info);
+        }
+        info.component = this.state.component;
+        return info;
+    }
+}
+AclService.decorators = [
+    { type: Injectable }
+];
+AclService.ctorParameters = () => [
+    { type: Injector },
+    { type: StateService },
+    { type: undefined, decorators: [{ type: Inject, args: [AUTH_SERVICE,] }] }
+];
+
+class BaseHttpClient extends HttpClient {
+    constructor(handler) {
+        super(handler);
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.extraRequestParams = {
+            language: "en"
+        };
+    }
+    makeHeaders(headers, withCredentials = true) {
+        headers = Object.assign({}, this.requestHeaders, headers);
+        const authHeader = headers["Authorization"] || "";
+        if (!withCredentials && !authHeader.startsWith("Bearer")) {
+            delete headers["Authorization"];
+        }
+        return new HttpHeaders(headers);
+    }
+    makeParams(params) {
+        params = Object.assign({}, this.extraRequestParams, this.requestParams, params);
+        return new HttpParams({
+            encoder: new HttpUrlEncodingCodec(),
+            fromObject: Object.keys(params || {}).reduce((result, key) => {
+                const value = params[key];
+                result[key] = ObjectUtils.isObject(value) ? JSON.stringify(value) : (ObjectUtils.isNullOrUndefined(value) ? "" : value.toString());
+                return result;
+            }, {})
+        });
+    }
+    setExtraRequestParam(name, value) {
+        if (typeof value == "undefined") {
+            delete this.extraRequestParams[name];
+            return;
+        }
+        this.extraRequestParams[name] = value;
+    }
+}
+BaseHttpClient.decorators = [
+    { type: Injectable }
+];
+BaseHttpClient.ctorParameters = () => [
+    { type: HttpHandler }
+];
+
+/**
+ * Use this service instead of Storage to avoid Angular Universal breaks on server environment
+ */
+class StorageService {
+    constructor(universal) {
+        this.universal = universal;
+    }
+    get(key, defaultValue, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return defaultValue;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        const item = storage.getItem(key);
+        if (!item)
+            return defaultValue;
+        try {
+            return JSON.parse(item);
+        }
+        catch (e) {
+            return item;
+        }
+    }
+    set(key, value, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        if (typeof value == "string") {
+            storage.setItem(key, value);
+            return;
+        }
+        storage.setItem(key, JSON.stringify(value));
+    }
+    remove(key, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        storage.removeItem(key);
+    }
+}
+StorageService.decorators = [
+    { type: Injectable }
+];
+StorageService.ctorParameters = () => [
+    { type: UniversalService }
+];
+
+class BaseHttpService {
+    constructor(client, storage, language, toaster, configs, request = null) {
+        this.client = client;
+        this.storage = storage;
+        this.language = language;
+        this.toaster = toaster;
+        this.configs = configs;
+        this.request = request;
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.cache = {};
+    }
+    get name() {
+        return "base";
+    }
+    get withCredentials() {
+        return true;
+    }
+    static retryFailedRequests() {
+        BaseHttpService.failedRequests.forEach(r => r());
+        BaseHttpService.failedRequests = [];
+    }
+    get universal() {
+        return this.storage.universal;
+    }
+    url(url) {
+        return url;
+    }
+    createUrl(url, params) {
+        const httpParams = this.client.makeParams(params);
+        const query = httpParams.keys().map(key => {
+            return `${key}=${httpParams.get(key)}`;
+        }).join("&");
+        return `${this.url(url)}?${query}`;
+    }
+    makeListParams(page, itemsPerPage, orderBy = null, orderDescending = null, filter = null) {
+        const params = {
+            page: (page - 1),
+            limit: itemsPerPage
+        };
+        if (!ObjectUtils.isNullOrUndefined(orderBy) && !ObjectUtils.isNullOrUndefined(orderDescending)) {
+            params.sort = `${orderDescending ? "-" : ""}${orderBy}`;
+        }
+        if (!ObjectUtils.isNullOrUndefined(filter)) {
+            params.filter = filter;
+        }
+        return params;
+    }
+    getPromise(url, options, body) {
+        options = this.makeOptions(options, "GET", body);
+        return this.toPromise(url, options);
+    }
+    deletePromise(url, options, body) {
+        options = this.makeOptions(options, "DELETE", body);
+        return this.toPromise(url, options);
+    }
+    postPromise(url, body, options) {
+        options = this.makeOptions(options, "POST", body);
+        return this.toPromise(url, options);
+    }
+    putPromise(url, body, options) {
+        options = this.makeOptions(options, "PUT", body);
+        return this.toPromise(url, options);
+    }
+    patchPromise(url, body, options) {
+        options = this.makeOptions(options, "PATCH", body);
+        return this.toPromise(url, options);
+    }
+    uploadPromise(url, body, listener, options) {
+        const headers = {};
+        if (body instanceof Blob) {
+            headers["Content-Type"] = "application/octet-stream";
+        }
+        options = this.makeOptions(Object.assign({
+            headers: headers,
+            reportProgress: true
+        }, options), "POST", body);
+        return this.toPromise(url, options, listener);
+    }
+    listPromise(url, params) {
+        return new Promise(resolve => {
+            this.getPromise(url, { params: params }).then(data => {
+                var _a, _b;
+                if (ObjectUtils.isArray(data)) {
+                    resolve({
+                        total: data.length,
+                        items: data,
+                        meta: {}
+                    });
+                    return;
+                }
+                resolve({
+                    total: ((_a = data.meta) === null || _a === void 0 ? void 0 : _a.total) || (data === null || data === void 0 ? void 0 : data.total) || ((_b = data.items) === null || _b === void 0 ? void 0 : _b.length) || 0,
+                    items: data.items || [],
+                    meta: data.meta || {}
+                });
+            }, response => {
+                if (response.status == 0 || response.status == 301) {
+                    resolve({
+                        total: 1,
+                        items: [{
+                                id: null,
+                                label: "Not implemented."
+                            }],
+                        meta: {}
+                    });
+                    return true;
+                }
+                resolve({
+                    total: 0,
+                    items: [],
+                    meta: {}
+                });
+                return false;
+            });
+        });
+    }
+    handleUnauthorizedError(absoluteUrl, options, reject) {
+        reject();
+        if (BaseHttpService.failedRequests.length > 1) {
+            return;
+        }
+        if (this.universal.isServer)
+            return;
+        console.log("User auth error", absoluteUrl, options);
+    }
+    toastWarning(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toastError(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toPromise(url, options, listener) {
+        const issueContext = { url: "" };
+        return new HttpPromise(response => {
+            if (!response) {
+                if (this.universal.isServer)
+                    return;
+                console.log("You may not need a reject Handler for this request!", this.name, url, options);
+                return;
+            }
+            const reason = response.error || {};
+            if (response.status == 0 || response.status == 301) {
+                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);
+                return;
+            }
+            const regex = /((E11000 duplicate key error collection: (.)+\.)|(_1 dup key:(.)+))/g;
+            if (reason.message && regex.test(reason.message)) {
+                this.toastError("message.duplicate-key.error." + reason.message.replace(regex, "").replace(" index: ", "-"), issueContext, reason, options);
+                return;
+            }
+            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);
+        }, (resolve, reject) => {
+            this.absoluteUrl(url, options).then(absoluteUrl => {
+                issueContext.url = absoluteUrl;
+                const request = this.client.request(options.method, absoluteUrl, options);
+                const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0
+                    ? request.pipe(timeout(options.timeout)) : request;
+                finalRequest.subscribe((event) => {
+                    if (options.reportProgress && event.type === HttpEventType.UploadProgress) {
+                        const progress = {
+                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),
+                            loaded: event.loaded,
+                            total: event.total
+                        };
+                        if (listener) {
+                            listener(progress);
+                        }
+                        return;
+                    }
+                    resolve(this.parseResponse(event, url, options));
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If we use token auth
+                    if (this.client.renewTokenFunc && headers.has(authKey)) {
+                        const currentTime = new Date().getTime();
+                        const userTokenTime = this.storage.get("userTokenTime") || currentTime;
+                        // And the last request was a long long time ago
+                        if (currentTime - 600000 > userTokenTime) {
+                            this.client.renewTokenFunc();
+                        }
+                    }
+                }, (response) => {
+                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {
+                        reject(response);
+                        return;
+                    }
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If an authorization header exists and we still have an Unauthorized response prompt the user to log in again
+                    if (headers.has(authKey) && response.status == 401) {
+                        const pushed = this.pushFailedRequest(url, options, () => {
+                            options.headers = this.makeHeaders(options.originalHeaders);
+                            this.toPromise(url, options, listener).then(resolve, reject);
+                        });
+                        if (pushed)
+                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));
+                        return;
+                    }
+                    reject(response);
+                });
+            });
+        });
+    }
+    pushFailedRequest(url, options, req) {
+        if (url.indexOf("tokens") >= 0)
+            return false;
+        BaseHttpService.failedRequests.push(req);
+        return true;
+    }
+    checkHeaders(headers) {
+        if (!headers || !headers.cookie || !headers.referer || !headers.host) {
+            return false;
+        }
+        return headers.referer.indexOf(headers.host) >= 0;
+    }
+    makeOptions(options, method = "GET", body) {
+        // Set base options
+        options = options ? Object.assign({}, options) : {};
+        options.method = method;
+        options.observe = options.observe || "body";
+        options.originalHeaders = options.originalHeaders || options.headers || {};
+        options.withCredentials = ObjectUtils.isBoolean(options.withCredentials) ? options.withCredentials : this.withCredentials;
+        options.body = body || {};
+        // Set cookies from server side request
+        const headers = !this.request ? null : this.request.headers;
+        if (this.checkHeaders(headers)) {
+            options.headers["Cookie"] = headers.cookie;
+        }
+        options.headers = this.makeHeaders(options);
+        options.params = this.makeParams(options);
+        return options;
+    }
+    makeHeaders(options) {
+        return this.client.makeHeaders(Object.assign({}, this.requestHeaders, (options === null || options === void 0 ? void 0 : options.headers) || {}));
+    }
+    makeParams(options) {
+        return this.client.makeParams(Object.assign({}, this.requestParams, (options === null || options === void 0 ? void 0 : options.params) || {}));
+    }
+    parseResponse(response, url, options) {
+        return response;
+    }
+    parseUrl(url) {
+        return this.url(url).replace(/(?:((?!:).\/)\/)/g, "$1");
+    }
+    absoluteUrl(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absoluteUrl = this.parseUrl(url);
+            if (url == "api-docs") {
+                return absoluteUrl.replace("/api", "");
+            }
+            return absoluteUrl;
+        });
+    }
+    expressRequestUrl(url) {
+        const req = this.request;
+        if (!req || !url || url.startsWith("http") || url.startsWith("//"))
+            return url;
+        const separator = url.startsWith("/") ? "" : "/";
+        return `${req.protocol}://${req.get("host")}${separator}${url}`;
+    }
+}
+BaseHttpService.failedRequests = [];
+BaseHttpService.decorators = [
+    { type: Injectable }
+];
+BaseHttpService.ctorParameters = () => [
+    { type: BaseHttpClient, decorators: [{ type: Inject, args: [BaseHttpClient,] }] },
+    { type: StorageService, decorators: [{ type: Inject, args: [StorageService,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [TOASTER_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [CONFIG_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [EXPRESS_REQUEST,] }] }
+];
+
+class ApiService extends BaseHttpService {
+    get name() {
+        return "api";
+    }
+    url(url) {
+        return this.expressRequestUrl(`/api/${url}`);
+    }
+    get(url, options, body) {
+        return this.getPromise(url, options, body);
+    }
+    delete(url, options, body) {
+        return this.deletePromise(url, options, body);
+    }
+    post(url, body, options) {
+        return this.postPromise(url, body, options);
+    }
+    put(url, body, options) {
+        return this.putPromise(url, body, options);
+    }
+    patch(url, body, options) {
+        return this.patchPromise(url, body, options);
+    }
+    upload(url, body, listener, options) {
+        return this.uploadPromise(url, body, listener, options);
+    }
+    list(url, params) {
+        return this.listPromise(url, params);
+    }
+}
+ApiService.decorators = [
+    { type: Injectable }
+];
+
+class StaticAuthService {
+    constructor() {
+        this.isAuthenticated = true;
+        this.userChanged = new EventEmitter();
+    }
+    checkAuthenticated() {
+        return Promise.resolve(this.isAuthenticated);
+    }
+    getReturnState(route) {
+        return null;
+    }
+}
+
+const JSON5 = require("json5");
+class ConfigService {
+    constructor(http, universal, injector, rootElement, baseConfig = null, scriptParams = null) {
+        this.http = http;
+        this.universal = universal;
+        this.injector = injector;
+        this.rootElement = rootElement;
+        for (const key in []) {
+            Object.defineProperty(Array.prototype, key, {
+                enumerable: false
+            });
+        }
+        let baseUrl = "";
+        if (this.universal.isBrowser) {
+            const currentScript = document.currentScript;
+            if (!!currentScript) {
+                const scriptSrc = currentScript.src;
+                const srcParts = scriptSrc.split(".js");
+                baseUrl = scriptSrc.substr(0, srcParts[0].lastIndexOf("/") + 1);
+            }
+        }
+        this.baseConfig = baseConfig || {};
+        this.loadedConfig = Object.assign(!baseUrl ? {} : { baseUrl, baseDomain: this.parseDomain(baseUrl) }, this.baseConfig);
+        this.scriptParameters = scriptParams || {};
+        this.loaderFunc = () => {
+            this.loader = this.loader || new Promise((resolve, reject) => {
+                this.loadJson().then(config => {
+                    this.loadedConfig = config = Object.assign(this.loadedConfig, config);
+                    this.prepareConfig(config).then(c => {
+                        this.loadedConfig = c;
+                        c.baseUrl = c.baseUrl || "/";
+                        resolve(c);
+                    });
+                }, reject);
+            });
+            return this.loader;
+        };
+        this.initService();
+    }
+    get load() {
+        return this.loaderFunc;
+    }
+    get config() {
+        return this.loadedConfig;
+    }
+    get configUrl() {
+        return `${this.loadedConfig.baseUrl}config/config.json`;
+    }
+    parseDomain(baseUrl) {
+        try {
+            const url = new URL(baseUrl);
+            const port = url.port && url.port !== "443" && url.port !== "80" ? `:${url.port}` : ``;
+            return `${url.protocol}//${url.hostname}${port}/`;
+        }
+        catch (_a) {
+            return "/";
+        }
+    }
+    initService() {
+    }
+    loadJson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.universal.isServer) {
+                return Promise.resolve(this.loadedConfig);
+            }
+            const configUrl = this.configUrl;
+            try {
+                const config5 = yield this.http.get(isDevMode() ? `${configUrl}5` : configUrl, { responseType: "text" }).toPromise();
+                return JSON5.parse(config5);
+            }
+            catch (e) {
+                try {
+                    const config = yield this.http.get(configUrl).toPromise();
+                    console.log(`Can't parse json5 config: ${e}`);
+                    return config;
+                }
+                catch (e) {
+                    throw new Error(`Config file not found at: ${configUrl}`);
+                }
+            }
+        });
+    }
+    prepareConfig(config) {
+        return Promise.resolve(config);
+    }
+    prepareUrl(url, ending) {
+        var _a;
+        const project = !this.loadedConfig ? "" : this.loadedConfig.project;
+        const needsProtocol = (_a = url === null || url === void 0 ? void 0 : url.startsWith("//")) !== null && _a !== void 0 ? _a : false;
+        url = !needsProtocol && (url === null || url === void 0 ? void 0 : url.startsWith("/")) ? this.loadedConfig.baseDomain + url.substr(1) : url || "";
+        url = `${url.replace(/\/+$/, "")}${ending}`.replace("[project]", project);
+        return this.universal.isServer && needsProtocol ? `http:${url}` : url;
+    }
+    getConfigValue(key) {
+        return this.loadedConfig[key];
+    }
+    getQueryParameter(name, url) {
+        url = url || (this.universal.isBrowser ? window.location.href : "");
+        name = name.replace(/[\[\]]/g, "\\$&");
+        const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"), results = regex.exec(url);
+        if (!results)
+            return null;
+        if (!results[2])
+            return "";
+        return decodeURIComponent(results[2].replace(/\+/g, " "));
+    }
+}
+ConfigService.decorators = [
+    { type: Injectable }
+];
+ConfigService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: UniversalService },
+    { type: Injector },
+    { type: undefined, decorators: [{ type: Inject, args: [ROOT_ELEMENT,] }] },
+    { type: IConfiguration, decorators: [{ type: Optional }, { type: Inject, args: [BASE_CONFIG,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [SCRIPT_PARAMS,] }] }
+];
+
+class ErrorHandlerService extends ErrorHandler {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.errorMap = {};
+    }
+    handleError(error) {
+        try {
+            this.universal = this.universal || this.injector.get(UniversalService);
+        }
+        catch (e) {
+            return;
+        }
+        const date = new Date();
+        try {
+            this.errorCb = this.errorCb || this.injector.get(ERROR_HANDLER);
+            this.errorCb(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+            if (this.universal.isServer) {
+                console.error(`[${date}]: ${error.message}\n${error.stack}`);
+                return;
+            }
+        }
+        if (this.universal.isServer)
+            return;
+        const key = typeof btoa !== "undefined" ? btoa(unescape(encodeURIComponent(`${error.message} ${error.stack}`))) : error.message;
+        if (this.errorMap[key] && this.errorMap[key].getTime() > date.getTime() - 5000)
+            return;
+        this.errorMap[key] = date;
+        try {
+            this.toaster = this.toaster || this.injector.get(TOASTER_SERVICE);
+            this.toaster.error(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+        }
+        console.error(`[${date}]: ${error.message}\n${error.stack}`);
+    }
+}
+ErrorHandlerService.decorators = [
+    { type: Injectable }
+];
+ErrorHandlerService.ctorParameters = () => [
+    { type: Injector }
+];
+
+class EventsService {
+    constructor() {
+        this.eventForwarded = new EventEmitter();
+        this.stickyUpdated = new EventEmitter();
+        this.languageChanged = new EventEmitter();
+        this.sticky = false;
+    }
+    get isSticky() {
+        return this.sticky;
+    }
+    event(e) {
+        this.eventForwarded.emit(e);
+    }
+    updateSticky(sticky) {
+        this.sticky = sticky;
+        this.stickyUpdated.emit(sticky);
+    }
+}
+EventsService.decorators = [
+    { type: Injectable }
+];
+EventsService.ctorParameters = () => [];
+
+class FormatterService {
+    constructor(language) {
+        this.language = language;
+    }
+    get defaultPrecision() {
+        return 2;
+    }
+    get defaultNumberFormat() {
+        return `num + ' mm'`;
+    }
+    get defaultDivider() {
+        return 1;
+    }
+    roundNumber(value, precision, divider) {
+        return MathUtils.round(value, this.getPrecision(precision), divider || this.defaultDivider);
+    }
+    formatNumber(value, format, precision, divider) {
+        precision = this.getPrecision(precision);
+        divider = divider || this.defaultDivider;
+        const num = ObjectUtils.isNumber(value) ? value : parseFloat(value) || 0;
+        const str = (num / divider).toLocaleString(this.language.currentLanguage, {
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+            useGrouping: false
+        });
+        return ObjectUtils.evaluate(format || this.defaultNumberFormat, { num: str });
+    }
+    formatMillimeter(value, precision, divider) {
+        return this.formatNumber(value, `num + ' mm'`, precision, divider);
+    }
+    getPrecision(precision) {
+        return ObjectUtils.isNumber(precision) ? precision : this.defaultPrecision;
+    }
+}
+FormatterService.decorators = [
+    { type: Injectable }
+];
+FormatterService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] }
+];
+
+class GlobalTemplateService {
+    constructor() {
+        this.templatesUpdated = new EventEmitter();
+        this.globalTemplates = {};
+        this.componentModifiers = {};
+    }
+    get(id, component) {
+        const template = this.globalTemplates[id];
+        if (!template)
+            return undefined;
+        const modifier = this.componentModifiers[id];
+        if (ObjectUtils.isFunction(modifier) && component) {
+            modifier(component);
+        }
+        return template;
+    }
+    add(id, template) {
+        this.globalTemplates[id] = template;
+        this.templatesUpdated.emit();
+    }
+    remove(id) {
+        delete this.globalTemplates[id];
+        this.templatesUpdated.emit();
+    }
+    addComponentModifier(id, modifier) {
+        this.componentModifiers[id] = modifier;
+    }
+}
+GlobalTemplateService.decorators = [
+    { type: Injectable }
+];
+GlobalTemplateService.ctorParameters = () => [];
+
+class IconService {
+    constructor() {
+        this.iconsLoaded = new EventEmitter();
+        this.disabled = false;
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    set isDisabled(value) {
+        this.disabled = value;
+        this.iconsLoaded.emit();
+    }
+    getIcon(icon, activeIcon, active) {
+        icon = typeof icons == "undefined" ? icon : (icons[icon] || icon);
+        activeIcon = typeof icons == "undefined" ? activeIcon : (icons[activeIcon] || icon);
+        return Promise.resolve(active ? activeIcon : icon);
+    }
+}
+IconService.decorators = [
+    { type: Injectable }
+];
+IconService.ctorParameters = () => [];
+
+class StaticLanguageService {
+    constructor(events, storage, configs, promises, client) {
+        this.events = events;
+        this.storage = storage;
+        this.configs = configs;
+        this.promises = promises;
+        this.client = client;
+        this.editLang = null;
+        this.currentLang = null;
+        this.disableTrans = false;
+        this.languageList = [];
+        this.translations = {
+            none: {}
+        };
+        this.initService();
+    }
+    get defaultLanguage() {
+        return this.configs.getQueryParameter("lang") || this.storage.get("language", this.getDefaultLanguage());
+    }
+    get dictionary() {
+        return this.translations[this.currentLanguage] || {};
+    }
+    set dictionary(value) {
+        this.translations[this.currentLanguage] = value;
+    }
+    get languages() {
+        return this.languageList;
+    }
+    get currentLanguage() {
+        return this.currentLang || this.defaultLanguage;
+    }
+    set currentLanguage(lang) {
+        this.currentLang = lang;
+        this.events.languageChanged.emit(lang);
+    }
+    get editLanguage() {
+        return this.editLang || this.currentLanguage;
+    }
+    set editLanguage(lang) {
+        this.editLang = lang || this.currentLanguage;
+    }
+    get disableTranslations() {
+        return this.disableTrans;
+    }
+    set disableTranslations(value) {
+        this.disableTrans = value;
+        this.events.languageChanged.emit(this.currentLang);
+    }
+    get httpClient() {
+        return this.client;
+    }
+    get config() {
+        return this.configs.config;
+    }
+    get universal() {
+        return this.storage.universal;
+    }
+    initService() {
+    }
+    replaceLanguages(languages) {
+        languages = Array.isArray(languages) && languages.length > 0 ? languages : this.languageList;
+        this.languageList = Array.from(new Set(languages));
+        this.languageList.forEach(lang => {
+            this.translations[lang] = this.translations[lang] || {};
+        });
+    }
+    addLanguages(languages) {
+        if (!Array.isArray(languages) || languages.length == 0)
+            return;
+        this.replaceLanguages(this.languageList.concat(languages));
+    }
+    getTranslationSync(key, params = null) {
+        const lowerKey = (key || "").toLocaleLowerCase();
+        const translation = this.dictionary[lowerKey] || lowerKey;
+        return this.interpolate(translation == lowerKey ? key : translation, params);
+    }
+    getTranslation(key, params) {
+        if (!ObjectUtils.isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        const translation = ObjectUtils.getValue(this.dictionary, key, key) || key;
+        return this.promises.resolve(this.interpolate(translation, params));
+    }
+    getTranslations(...keys) {
+        return this.promises.create(resolve => {
+            this.promises.all(keys.map(key => this.getTranslation(key))).then(translations => {
+                resolve(keys.reduce((result, key, i) => {
+                    result[key] = translations[i];
+                    return result;
+                }, {}));
+            });
+        });
+    }
+    getTranslationFromObject(translations, params, lang) {
+        lang = lang || this.currentLanguage;
+        return this.interpolate(translations ? (translations[lang] || "") : "");
+    }
+    getTranslationFromArray(translations, params, lang) {
+        lang = lang || this.currentLanguage;
+        const translation = translations ? translations.find(t => t.lang == lang) : null;
+        return this.interpolate(translation ? translation.translation : "", params);
+    }
+    interpolate(expr, params) {
+        if (typeof expr === "string") {
+            return this.interpolateString(expr, params);
+        }
+        if (typeof expr === "function") {
+            return expr(params);
+        }
+        return expr;
+    }
+    interpolateString(expr, params) {
+        if (!expr || !params)
+            return expr;
+        return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
+            const r = ObjectUtils.getValue(params, b);
+            return ObjectUtils.isDefined(r) ? r : substring;
+        });
+    }
+    getDefaultLanguage() {
+        if (!this.universal.isBrowser || typeof window.navigator === "undefined") {
+            return "de";
+        }
+        let browserLang = (window.navigator.languages ? window.navigator.languages[0] : null)
+            || window.navigator.language || window.navigator["browserLanguage"] || window.navigator["userLanguage"] || null;
+        if (!browserLang)
+            return browserLang;
+        ["-", "_"].forEach(splitter => {
+            if (browserLang.indexOf(splitter) >= 0) {
+                browserLang = browserLang.split(splitter)[0];
+            }
+        });
+        return browserLang;
+    }
+}
+StaticLanguageService.decorators = [
+    { type: Injectable }
+];
+StaticLanguageService.ctorParameters = () => [
+    { type: EventsService, decorators: [{ type: Inject, args: [EventsService,] }] },
+    { type: StorageService, decorators: [{ type: Inject, args: [StorageService,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [CONFIG_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [PROMISE_SERVICE,] }] },
+    { type: BaseHttpClient, decorators: [{ type: Inject, args: [BaseHttpClient,] }] }
+];
+
+class LanguageService extends StaticLanguageService {
+    get currentLanguage() {
+        return this.currentLang || this.defaultLanguage;
+    }
+    set currentLanguage(lang) {
+        this.useLanguage(lang).then(() => {
+            this.events.languageChanged.emit(lang);
+        });
+    }
+    get settings() {
+        const settings = this.languageSettings.value;
+        return !settings ? {} : settings.settings[this.currentLanguage] || {};
+    }
+    get $settings() {
+        this.loadSettings().then(s => this.languageSettings.next(s));
+        return combineLatest([this.languageSettings, this.events.languageChanged]).pipe(map(([settings, lang]) => {
+            return !settings ? {} : settings.settings[lang] || {};
+        }));
+    }
+    initService() {
+        this.client.setExtraRequestParam("language", "de");
+        this.translationRequests = {};
+        this.languageSettings = new BehaviorSubject(null);
+        if (this.universal.isServer)
+            return;
+        window["setLanguage"] = (lang) => {
+            this.currentLanguage = lang;
+        };
+    }
+    initFromSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultLanguage = this.defaultLanguage;
+            const settings = yield this.loadSettings();
+            this.languageSettings.next(settings);
+            const devLanguages = settings.devLanguages || [];
+            this.languageList = (settings.languages || []).filter(lang => {
+                return devLanguages.indexOf(lang) < 0;
+            });
+            const lang = this.languages.indexOf(defaultLanguage) < 0 ? settings.defaultLanguage : defaultLanguage;
+            yield this.useLanguage(lang);
+            this.events.languageChanged.emit(lang);
+        });
+    }
+    getTranslation(key, params = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!key)
+                return "";
+            try {
+                const lowerKey = key.toLocaleLowerCase();
+                const dict = yield this.loadDictionary();
+                if (lowerKey in dict) {
+                    return this.interpolate(dict[lowerKey], params);
+                }
+                return this.interpolate(key, params);
+            }
+            catch (reason) {
+                console.log("ERROR IN TRANSLATIONS", reason);
+                return key;
+            }
+        });
+    }
+    useLanguage(lang) {
+        return __awaiter(this, void 0, void 0, function* () {
+            lang = this.languages.indexOf(lang) < 0 ? this.languages[0] : lang;
+            this.client.setExtraRequestParam("language", lang);
+            if (lang == this.currentLang)
+                return this.dictionary;
+            this.storage.set("language", lang);
+            this.currentLang = lang;
+            const dict = yield this.loadDictionary();
+            this.translations[lang] = dict;
+            return dict;
+        });
+    }
+    loadDictionary() {
+        const lang = this.currentLanguage;
+        this.translationRequests[lang] = this.translationRequests[lang] || new Promise(resolve => {
+            this.httpClient.get(`${this.config.translationUrl}${lang}`).toPromise().then(response => {
+                response = response || {};
+                resolve(Object.keys(response).reduce((result, key) => {
+                    result[key.toLocaleLowerCase()] = response[key];
+                    return result;
+                }, {}));
+            }, () => {
+                resolve({});
+            });
+        });
+        return this.translationRequests[lang];
+    }
+    loadSettings() {
+        this.settingsPromise = this.settingsPromise || this.client.get(`${this.config.translationUrl}languageSettings`).toPromise()
+            .then((settings) => {
+            return settings;
+        }, () => {
+            return {
+                languages: ["de", "en", "hu"],
+                devLanguages: [],
+                defaultLanguage: "de",
+                settings: {
+                    de: {},
+                    hu: {},
+                    end: {}
+                }
+            };
+        });
+        return this.settingsPromise;
+    }
+}
+LanguageService.decorators = [
+    { type: Injectable }
+];
+
+class OpenApiService {
+    constructor(api) {
+        this.api = api;
+    }
+    getSchemas() {
+        this.schemasPromise = this.schemasPromise || new Promise((resolve => {
+            this.api.get("api-docs").then(res => {
+                var _a;
+                const schemas = ((_a = res.components) === null || _a === void 0 ? void 0 : _a.schemas) || res.definitions || {};
+                Object.values(schemas).forEach(schema => {
+                    Object.keys(schema.properties || {}).forEach(p => {
+                        schema.properties[p].id = p;
+                    });
+                });
+                resolve(schemas);
+            }, () => {
+                resolve({});
+            });
+        }));
+        return this.schemasPromise;
+    }
+    getSchema(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemas = yield this.getSchemas();
+            const schema = schemas[name];
+            if (!schema)
+                return null;
+            return schemas[name];
+        });
+    }
+}
+OpenApiService.decorators = [
+    { type: Injectable }
+];
+OpenApiService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [API_SERVICE,] }] }
+];
+
+class ConsoleToasterService {
+    constructor(language) {
+        this.language = language;
+    }
+    error(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #BD362F; color: #ffffff"));
+    }
+    info(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #2F96B4; color: #ffffff"));
+    }
+    success(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #51A351; color: #ffffff"));
+    }
+    warning(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #F89406; color: #ffffff"));
+    }
+    translateMessage(message, params, callback) {
+        this.language.getTranslation(message, params).then(callback);
+    }
+}
+ConsoleToasterService.decorators = [
+    { type: Injectable }
+];
+ConsoleToasterService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] }
+];
+
+class TranslatedUrlSerializer extends DefaultUrlSerializer {
+    constructor(language) {
+        super();
+        this.language = language;
+        this.cache = {};
+    }
+    serialize(tree) {
+        const copy = new UrlTree();
+        const dictionary = this.getDictionary(true);
+        copy.root = this.modifyTreeRecursive(tree.root, segment => {
+            segment.path = dictionary[segment.path] || segment.path;
+        });
+        copy.queryParams = tree.queryParams;
+        return super.serialize(copy);
+    }
+    parse(url) {
+        const tree = super.parse(url);
+        const dictionary = this.getDictionary(false);
+        tree.root = this.modifyTreeRecursive(tree.root, segment => {
+            segment.path = dictionary[segment.path] || segment.path;
+        });
+        return tree;
+    }
+    getDictionary(serialize) {
+        const method = serialize ? `serialize` : `parse`;
+        const key = `${this.language.currentLanguage}-${method}`;
+        if (!this.cache[key]) {
+            const dict = this.language.dictionary;
+            this.cache[key] = Object.keys(dict).reduce((res, key) => {
+                if (!key.startsWith("route."))
+                    return res;
+                const value = dict[key];
+                key = key.replace("route.", "");
+                res[serialize ? key : value] = serialize ? value : key;
+                return res;
+            }, {});
+        }
+        return this.cache[key];
+    }
+    modifyTreeRecursive(segmentGroup, cb) {
+        if (!segmentGroup)
+            return null;
+        const childrenArr = [];
+        const children = Object.keys(segmentGroup.children || {}).reduce((res, key) => {
+            const child = this.modifyTreeRecursive(segmentGroup.children[key], cb);
+            childrenArr.push(child);
+            res[key] = child;
+            return res;
+        }, {});
+        const newGroup = new UrlSegmentGroup(segmentGroup.segments.map(s => {
+            s = new UrlSegment(s.path, Object.assign({}, s.parameters));
+            cb(s);
+            return s;
+        }), children);
+        childrenArr.forEach(c => {
+            c.parent = newGroup;
+        });
+        return newGroup;
+    }
+}
+TranslatedUrlSerializer.decorators = [
+    { type: Injectable }
+];
+TranslatedUrlSerializer.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] }
+];
+
+class PromiseService {
+    constructor(zone) {
+        this.zone = zone;
+        this.promiseCount = 0;
+        this.promiseChanged = new EventEmitter();
+    }
+    get count() {
+        return this.promiseCount;
+    }
+    get onChanged() {
+        return this.promiseChanged;
+    }
+    create(executor) {
+        return this.add(this.zone.runOutsideAngular(() => new Promise(executor)));
+    }
+    all(promises) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.all(promises)));
+    }
+    resolve(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.resolve(value)));
+    }
+    reject(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.reject(value)));
+    }
+    promiseFinished() {
+        if (this.promiseCount == 0)
+            return;
+        this.promiseCount--;
+        this.promiseChanged.emit(this.promiseCount);
+    }
+    add(promise) {
+        this.promiseCount++;
+        this.promiseChanged.emit(this.promiseCount);
+        return new Promise((resolve, reject) => {
+            promise.then(v => {
+                resolve(v);
+                this.promiseFinished();
+            }, r => {
+                reject(r);
+                this.promiseFinished();
+            });
+        });
+    }
+}
+PromiseService.decorators = [
+    { type: Injectable }
+];
+PromiseService.ctorParameters = () => [
+    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] }
+];
+
+function emptyRemove$1() {
+}
+function isWindow(el) {
+    return typeof window !== "undefined" && el === window;
+}
+class ResizeEventPlugin extends ɵangular_packages_platform_browser_platform_browser_g {
+    constructor(doc, universal) {
+        super(doc);
+        this.universal = universal;
+    }
+    supports(eventName) {
+        return eventName === ResizeEventPlugin.EVENT_NAME;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        return zone.runOutsideAngular(() => {
+            if (this.universal.isServer)
+                return emptyRemove$1;
+            const cb = el => {
+                zone.run(() => handler(el));
+            };
+            if (isWindow(element)) {
+                element.addEventListener(eventName, cb);
+            }
+            else {
+                addListener(element, cb);
+            }
+            return () => {
+                try {
+                    if (isWindow(element)) {
+                        element.removeEventListener(eventName, cb);
+                    }
+                    else {
+                        removeListener(element, cb);
+                    }
+                }
+                catch (e) {
+                }
+            };
+        });
+    }
+}
+ResizeEventPlugin.EVENT_NAME = "resize";
+ResizeEventPlugin.decorators = [
+    { type: Injectable }
+];
+ResizeEventPlugin.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: UniversalService }
+];
+
+function emptyRemove() {
+}
+class ScrollEventPlugin extends ɵangular_packages_platform_browser_platform_browser_g {
+    constructor(doc, universal) {
+        super(doc);
+        this.universal = universal;
+    }
+    supports(eventName) {
+        return eventName === ScrollEventPlugin.EVENT_NAME;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        return zone.runOutsideAngular(() => {
+            if (this.universal.isServer)
+                return emptyRemove;
+            const callback = (e) => {
+                zone.run(() => handler(e));
+            };
+            element.addEventListener(eventName, callback);
+            return () => element.removeEventListener(eventName, callback);
+        });
+    }
+}
+ScrollEventPlugin.EVENT_NAME = "scroll";
+ScrollEventPlugin.decorators = [
+    { type: Injectable }
+];
+ScrollEventPlugin.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: UniversalService }
+];
+
+class ChunkPipe {
+    transform(items, count) {
+        const result = [];
+        let subResult = null;
+        items.forEach((item, index) => {
+            if (index % count == 0) {
+                subResult = [];
+                result.push(subResult);
+            }
+            subResult.push(item);
+        });
+        return result;
+    }
+}
+ChunkPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "chunk"
+            },] }
+];
+
+const emptyEntries = [];
+class EntriesPipe {
+    transform(value) {
+        if (!value)
+            return emptyEntries;
+        const entries = [];
+        ObjectUtils.iterate(value, (val, key) => {
+            entries.push({
+                key: key,
+                value: val,
+                index: entries.length
+            });
+        });
+        return entries;
+    }
+}
+EntriesPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "entries"
+            },] }
+];
+
+class ExtraItemPropertiesPipe {
+    transform(items, properties, params = {}) {
+        const keys = Object.keys(properties);
+        keys.forEach(key => {
+            const value = properties[key];
+            properties[key] = ObjectUtils.isFunction(value) ? value : (item, index, params) => {
+                return ObjectUtils.evaluate(value, {
+                    item: item,
+                    index: index,
+                    params: params
+                });
+            };
+        });
+        return (items || []).map((item, index) => keys.reduce((result, key) => {
+            result[key] = properties[key](item, index, params);
+            return result;
+        }, Object.assign({}, item)));
+    }
+}
+ExtraItemPropertiesPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "extraItemProperties"
+            },] }
+];
+
+function defaultFilter$1() {
+    return true;
+}
+class FilterPipe {
+    transform(values, filter = defaultFilter$1, params = {}) {
+        const isObject = ObjectUtils.isObject(values);
+        if (!isObject && !ObjectUtils.isArray(values))
+            return [];
+        const filterFunc = ObjectUtils.isFunction(filter) ? filter : (value, key, params) => {
+            return ObjectUtils.evaluate(filter, {
+                value: value,
+                key: key,
+                item: value,
+                index: key,
+                params: params
+            });
+        };
+        if (isObject) {
+            return Object.keys(values).filter(key => {
+                return filterFunc(values[key], key, params);
+            }).reduce((result, key) => {
+                result[key] = values[key];
+                return result;
+            }, {});
+        }
+        return values.filter((value, key) => {
+            return filterFunc(value, key, params);
+        });
+    }
+}
+FilterPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "filter"
+            },] }
+];
+
+function defaultFilter() {
+    return true;
+}
+class FindPipe {
+    transform(values, filter = defaultFilter, params = {}) {
+        if (!ObjectUtils.isArray(values))
+            return [];
+        const filterFunc = ObjectUtils.isFunction(filter) ? filter : (value, index, params) => {
+            return ObjectUtils.evaluate(filter, {
+                value: value,
+                index: index,
+                params: params
+            });
+        };
+        return values.find((value, index) => filterFunc(value, index, params));
+    }
+}
+FindPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "find"
+            },] }
+];
+
+class FormatNumberPipe {
+    constructor(formatter) {
+        this.formatter = formatter;
+    }
+    transform(value, format, precision, divider) {
+        return this.formatter.formatNumber(value, format, precision, divider);
+    }
+}
+FormatNumberPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "formatNumber"
+            },] }
+];
+FormatNumberPipe.ctorParameters = () => [
+    { type: FormatterService }
+];
+
+class GetOffsetPipe {
+    transform(value, offset) {
+        return value ? (ObjectUtils.isNullOrUndefined(offset) ? value : value[offset]) : null;
+    }
+}
+GetOffsetPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "getOffset"
+            },] }
+];
+
+class GetTypePipe {
+    transform(value) {
+        return typeof value;
+    }
+}
+GetTypePipe.decorators = [
+    { type: Pipe, args: [{
+                name: "getType"
+            },] }
+];
+
+class GlobalTemplatePipe {
+    constructor(globalTemplates) {
+        this.globalTemplates = globalTemplates;
+        this.cachedTemplateId = null;
+        this.cachedTemplate = null;
+    }
+    ngOnInit() {
+        this.templatesUpdated = this.globalTemplates.templatesUpdated.subscribe(() => {
+            this.cachedTemplate = null;
+        });
+    }
+    ngOnDestroy() {
+        if (this.templatesUpdated)
+            this.templatesUpdated.unsubscribe();
+    }
+    transform(templateId, component) {
+        if (!templateId)
+            return null;
+        if (this.cachedTemplate === null || this.cachedTemplateId !== templateId) {
+            this.cachedTemplateId = templateId;
+            this.cachedTemplate = this.globalTemplates.get(templateId, component);
+        }
+        return this.cachedTemplate;
+    }
+}
+GlobalTemplatePipe.decorators = [
+    { type: Pipe, args: [{
+                pure: false,
+                name: "globalTemplate"
+            },] }
+];
+GlobalTemplatePipe.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [GLOBAL_TEMPLATES,] }] }
+];
+
+class GroupByPipe {
+    transform(records, column, map = null) {
+        const groups = (records || []).reduce((result, item) => {
+            const key = ObjectUtils.getValue(item, column) || "";
+            const col = map ? (map[key] || "") : key;
+            const group = result[col] || [];
+            group.push(item);
+            result[col] = group;
+            return result;
+        }, {});
+        return Object.keys(groups).map(key => {
+            return { group: key, items: groups[key] };
+        });
+    }
+}
+GroupByPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "groupBy"
+            },] }
+];
+
+class IsTypePipe {
+    transform(value, type) {
+        return (typeof value) === type;
+    }
+}
+IsTypePipe.decorators = [
+    { type: Pipe, args: [{
+                name: "isType"
+            },] }
+];
+
+class JoinPipe {
+    transform(value, separator = ", ") {
+        return (ObjectUtils.isArray(value))
+            ? value.join(separator)
+            : "";
+    }
+}
+JoinPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "join"
+            },] }
+];
+
+const emptyKeys = [];
+class KeysPipe {
+    transform(value) {
+        if (!value)
+            return emptyKeys;
+        return ObjectUtils.isArray(value)
+            ? Array.from(value.keys())
+            : Object.keys(value);
+    }
+}
+KeysPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "keys"
+            },] }
+];
+
+function defaultMapper(item) {
+    return item;
+}
+class MapPipe {
+    transform(values, mapper = defaultMapper, params = {}) {
+        if (!ObjectUtils.isArray(values))
+            return [];
+        const mapperFunc = ObjectUtils.isFunction(mapper) ? mapper : (value, index, params) => {
+            return ObjectUtils.evaluate(mapper, {
+                value: value,
+                index: index,
+                params: params
+            });
+        };
+        return values.map((value, index) => mapperFunc(value, index, params));
+    }
+}
+MapPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "map"
+            },] }
+];
+
+class MaxPipe {
+    transform(value, selector = null, params = {}) {
+        selector = selector || (item => item);
+        const maxSelector = ObjectUtils.isFunction(value) ? value : (item, index, params) => {
+            return ObjectUtils.evaluate(selector, {
+                item: item,
+                index: index,
+                params: params
+            });
+        };
+        return ArrayUtils.max(value, (item, index) => maxSelector(item, index, params));
+    }
+}
+MaxPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "max"
+            },] }
+];
+
+class MinPipe {
+    transform(value, selector = null, params = {}) {
+        selector = selector || (item => item);
+        const minSelector = ObjectUtils.isFunction(value) ? value : (item, index, params) => {
+            return ObjectUtils.evaluate(selector, {
+                item: item,
+                index: index,
+                params: params
+            });
+        };
+        return ArrayUtils.min(value, (item, index) => minSelector(item, index, params));
+    }
+}
+MinPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "min"
+            },] }
+];
+
+class PopPipe {
+    transform(value) {
+        return !Array.isArray(value) ? null : Array.from(value).pop();
+    }
+}
+PopPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "pop"
+            },] }
+];
+
+function defaultReducer(result) {
+    return result;
+}
+class ReducePipe {
+    transform(values, source, reducer = defaultReducer, params = {}) {
+        if (!ObjectUtils.isArray(values))
+            return [];
+        const mapperFunc = ObjectUtils.isFunction(reducer) ? reducer : (result, value, index, params) => {
+            return ObjectUtils.evaluate(reducer, {
+                result: result,
+                value: value,
+                index: index,
+                params: params
+            });
+        };
+        return values.reduce((result, value, index) => mapperFunc(result, value, index, params), source);
+    }
+}
+ReducePipe.decorators = [
+    { type: Pipe, args: [{
+                name: "reduce"
+            },] }
+];
+
+const empty = {};
+class RemapPipe {
+    transform(map, source, defaultValue = "key") {
+        if (!map)
+            return empty;
+        if (!source)
+            return map;
+        const remapped = ObjectUtils.filter({ map: ObjectUtils.copy(map) }, (value, key, target) => {
+            if (ObjectUtils.isArray(value) && value.every(ObjectUtils.isString)) {
+                target[key] = value.reduce((result, k) => {
+                    result[k] = ObjectUtils.getValue(source, k, ObjectUtils.evaluate(defaultValue, { key: k, map: map, source: source }));
+                    return result;
+                }, {});
+                return false;
+            }
+            return true;
+        });
+        return remapped.map;
+    }
+}
+RemapPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "remap"
+            },] }
+];
+
+class ReplacePipe {
+    transform(value, from, to) {
+        return value ? value.replace(from, to) : value;
+    }
+}
+ReplacePipe.decorators = [
+    { type: Pipe, args: [{
+                name: "replace"
+            },] }
+];
+
+const emptyArray = [];
+class ReversePipe {
+    transform(value) {
+        if (!ObjectUtils.isArray(value))
+            return emptyArray;
+        const result = [];
+        for (let i = value.length - 1; i >= 0; i--) {
+            result.push(value[i]);
+        }
+        return result;
+    }
+}
+ReversePipe.decorators = [
+    { type: Pipe, args: [{
+                name: "reverse"
+            },] }
+];
+
+class RoundPipe {
+    constructor(formatter) {
+        this.formatter = formatter;
+    }
+    transform(value, precision = 2, divider = 1) {
+        return this.formatter.roundNumber(value, precision, divider);
+    }
+}
+RoundPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "round"
+            },] }
+];
+RoundPipe.ctorParameters = () => [
+    { type: FormatterService }
+];
+
+class SafeHtmlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value, type = "html") {
+        switch (type) {
+            case "html":
+                return this.sanitizer.bypassSecurityTrustHtml(value);
+            case "style":
+                return this.sanitizer.bypassSecurityTrustStyle(value);
+            case "script":
+                return this.sanitizer.bypassSecurityTrustScript(value);
+            case "url":
+                return this.sanitizer.bypassSecurityTrustUrl(value);
+            case "resourceUrl":
+                return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+            default:
+                throw new Error(`SafePipe unable to bypass security for invalid type: ${type}`);
+        }
+    }
+}
+SafeHtmlPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "safe"
+            },] }
+];
+SafeHtmlPipe.ctorParameters = () => [
+    { type: DomSanitizer }
+];
+
+class ShiftPipe {
+    transform(value) {
+        return !Array.isArray(value) ? null : Array.from(value).shift();
+    }
+}
+ShiftPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "shift"
+            },] }
+];
+
+class SplitPipe {
+    transform(value, separator = ".") {
+        return `${value}`.split(separator);
+    }
+}
+SplitPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "split"
+            },] }
+];
+
+class TranslatePipe {
+    constructor(cdr, language) {
+        this.cdr = cdr;
+        this.language = language;
+    }
+    get currentLang() {
+        return this.language.currentLanguage;
+    }
+    transform(query, ...args) {
+        if (!query)
+            return "";
+        let dirty = false;
+        const lang = this.currentLang;
+        if (this.lang !== lang) {
+            this.lang = lang;
+            dirty = true;
+        }
+        const disabled = this.language.disableTranslations;
+        if (this.disabled !== disabled) {
+            this.disabled = disabled;
+            dirty = true;
+        }
+        if (!ObjectUtils.equals(this.query, query)) {
+            this.query = query;
+            dirty = true;
+        }
+        if (!ObjectUtils.equals(this.args, args)) {
+            this.args = args;
+            this.params = null;
+            if (ObjectUtils.isDefined(args[0]) && args.length) {
+                if (typeof args[0] === "string" && args[0].length) {
+                    const validArgs = args[0]
+                        .replace(/(\')?([a-zA-Z0-9_]+)(\')?(\s)?:/g, `"$2":`)
+                        .replace(/:(\s)?(\')(.*?)(\')/g, `:"$3"`);
+                    try {
+                        this.params = JSON.parse(validArgs);
+                    }
+                    catch (e) {
+                        throw new SyntaxError(`Wrong parameter in TranslatePipe. Expected a valid Object, received: ${args[0]}`);
+                    }
+                }
+                else if (typeof args[0] === "object" && !Array.isArray(args[0])) {
+                    this.params = args[0];
+                }
+            }
+            dirty = true;
+        }
+        if (dirty) {
+            if (typeof query === "object") {
+                this.lastValue = Array.isArray(query) ? this.language.getTranslationFromArray(query, this.params, lang) : this.language.getTranslationFromObject(query, this.params, lang);
+                return this.lastValue;
+            }
+            if (this.disabled) {
+                this.lastValue = query;
+                return this.lastValue;
+            }
+            this.language.getTranslation(query, this.params).then(value => {
+                this.lastValue = value;
+                if (!this.cdr["destroyed"]) {
+                    this.cdr.detectChanges();
+                }
+            });
+        }
+        return this.lastValue;
+    }
+}
+TranslatePipe.decorators = [
+    { type: Injectable },
+    { type: Pipe, args: [{
+                name: "translate",
+                pure: false
+            },] }
+];
+TranslatePipe.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] }
+];
+
+const emptyValues = [];
+class ValuesPipe {
+    transform(value) {
+        if (!value)
+            return emptyValues;
+        return ObjectUtils.isArray(value)
+            ? value
+            : Object.keys(value).map(key => value[key]);
+    }
+}
+ValuesPipe.decorators = [
+    { type: Pipe, args: [{
+                name: "values"
+            },] }
+];
+
+class AsyncMethodBase {
+    constructor(toaster) {
+        this.toaster = toaster;
+        this.onSuccess = new EventEmitter();
+        this.onError = new EventEmitter();
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    get isLoading() {
+        return this.loading;
+    }
+    click() {
+        if (this.disabled)
+            return;
+        this.callMethod();
+    }
+    callMethod() {
+        if (this.loading)
+            return true;
+        this.loading = true;
+        const method = this.getMethod();
+        const result = !method ? null : method(this.context);
+        if (!(result instanceof Promise)) {
+            this.loading = false;
+            return false;
+        }
+        result.then(result => {
+            this.loading = false;
+            if (result) {
+                this.onSuccess.emit(result);
+                this.toaster.success(result.message, result.context);
+            }
+        }, reason => {
+            if (!reason || !reason.message)
+                throw new Error("Reason must implement IAsyncMessage interface");
+            this.loading = false;
+            this.onError.emit(reason);
+            this.toaster.error(reason.message, reason.context);
+        });
+        return true;
+    }
+}
+AsyncMethodBase.propDecorators = {
+    disabled: [{ type: Input }],
+    context: [{ type: Input }],
+    onSuccess: [{ type: Output }],
+    onError: [{ type: Output }],
+    isDisabled: [{ type: HostBinding, args: ["class.disabled",] }],
+    isLoading: [{ type: HostBinding, args: ["class.loading",] }],
+    click: [{ type: HostListener, args: ["click",] }]
+};
+
+class AsyncMethodDirective extends AsyncMethodBase {
+    constructor(toaster) {
+        super(toaster);
+    }
+    getMethod() {
+        return this.method;
+    }
+}
+AsyncMethodDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[async-method]",
+                exportAs: "async-method"
+            },] }
+];
+AsyncMethodDirective.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [TOASTER_SERVICE,] }] }
+];
+AsyncMethodDirective.propDecorators = {
+    method: [{ type: Input, args: ["async-method",] }]
+};
+
+const defaultClass = "default-image";
+const loadingClass = "loading-image";
+class BackgroundDirective {
+    constructor(http, element, renderer, universal) {
+        this.http = http;
+        this.element = element;
+        this.renderer = renderer;
+        this.universal = universal;
+    }
+    ngOnChanges(changes) {
+        if (this.universal.isServer) {
+            this.setBackground(this.background);
+            return;
+        }
+        this.renderer.removeClass(this.element.nativeElement, defaultClass);
+        this.renderer.addClass(this.element.nativeElement, loadingClass);
+        FileUtils.readDataFromUrl(this.http, this.background).then(url => {
+            this.setBackground(url);
+        }, () => {
+            this.renderer.removeClass(this.element.nativeElement, loadingClass);
+            this.renderer.addClass(this.element.nativeElement, defaultClass);
+        });
+    }
+    setBackground(url) {
+        this.renderer.removeClass(this.element.nativeElement, loadingClass);
+        this.renderer.setStyle(this.element.nativeElement, "background-image", `url('${url}')`);
+        if (!this.backgroundSize)
+            return;
+        this.renderer.setStyle(this.element.nativeElement, "background-size", this.backgroundSize);
+    }
+}
+BackgroundDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[background]"
+            },] }
+];
+BackgroundDirective.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: UniversalService }
+];
+BackgroundDirective.propDecorators = {
+    background: [{ type: Input }],
+    backgroundSize: [{ type: Input }]
+};
+
+class DynamicTableTemplateDirective {
+    constructor(ref) {
+        this.ref = ref;
+    }
+}
+DynamicTableTemplateDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "ng-template[column]"
+            },] }
+];
+DynamicTableTemplateDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+DynamicTableTemplateDirective.propDecorators = {
+    column: [{ type: Input }],
+    pure: [{ type: Input }]
+};
+
+class GlobalTemplateDirective {
+    constructor(globalTemplates, template) {
+        this.globalTemplates = globalTemplates;
+        this.template = template;
+    }
+    ngOnInit() {
+        this.globalTemplates.add(this.id, this.template);
+    }
+    ngOnDestroy() {
+        this.globalTemplates.remove(this.id);
+    }
+}
+GlobalTemplateDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[globalTemplate]"
+            },] }
+];
+GlobalTemplateDirective.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [GLOBAL_TEMPLATES,] }] },
+    { type: TemplateRef }
+];
+GlobalTemplateDirective.propDecorators = {
+    id: [{ type: Input, args: ["globalTemplate",] }]
+};
+
+class IconDirective {
+    constructor(element, renderer, icons) {
+        this.element = element;
+        this.renderer = renderer;
+        this.icons = icons;
+        this.renderer.addClass(this.element.nativeElement, "svg-icon");
+        this.activeChange = new EventEmitter();
+    }
+    get isActive() {
+        return this.active;
+    }
+    ngOnInit() {
+        this.iconsLoaded = this.icons.iconsLoaded.subscribe(() => this.changeIcon());
+    }
+    ngOnDestroy() {
+        if (this.iconsLoaded)
+            this.iconsLoaded.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        if (changes.icon) {
+            this.renderer.removeClass(this.element.nativeElement, `svg-icon-${changes.icon.previousValue}`);
+            this.renderer.addClass(this.element.nativeElement, `svg-icon-${changes.icon.currentValue}`);
+        }
+        this.changeIcon();
+    }
+    click() {
+        this.active = !this.active;
+        this.activeChange.emit(this.active);
+        this.changeIcon();
+    }
+    changeIcon() {
+        this.icons.getIcon(this.icon, this.activeIcon || `${this.icon}-active`, this.active).then(icon => {
+            if (this.icons.isDisabled)
+                return;
+            this.element.nativeElement.innerHTML = icon;
+        });
+    }
+}
+IconDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[icon]"
+            },] }
+];
+IconDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: undefined, decorators: [{ type: Inject, args: [ICON_SERVICE,] }] }
+];
+IconDirective.propDecorators = {
+    icon: [{ type: Input }],
+    activeIcon: [{ type: Input }],
+    active: [{ type: Input }],
+    activeChange: [{ type: Output }],
+    isActive: [{ type: HostBinding, args: ["class.active",] }],
+    click: [{ type: HostListener, args: ["click",] }]
+};
+
+class NgxTemplateOutletDirective {
+    constructor(_viewContainerRef) {
+        this._viewContainerRef = _viewContainerRef;
+    }
+    static hasContextShapeChanged(ctxChange) {
+        const prevCtxKeys = Object.keys(ctxChange.previousValue || {});
+        const currCtxKeys = Object.keys(ctxChange.currentValue || {});
+        if (prevCtxKeys.length === currCtxKeys.length) {
+            for (const propName of currCtxKeys) {
+                if (prevCtxKeys.indexOf(propName) === -1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    ngOnChanges(changes) {
+        const recreateView = this.shouldRecreateView(changes);
+        if (recreateView) {
+            if (this.viewRef)
+                this._viewContainerRef.remove(this._viewContainerRef.indexOf(this.viewRef));
+            if (this.ngxTemplateOutlet)
+                this.viewRef = this._viewContainerRef.createEmbeddedView(this.ngxTemplateOutlet, {});
+        }
+        this.ngDoCheck();
+    }
+    ngDoCheck() {
+        if (!this.viewRef)
+            return;
+        const context = this.viewRef.context;
+        this.updateExistingContext(this.context, context);
+        this.updateExistingContext(this.additionalContext, context);
+        context.$implicit = context;
+    }
+    shouldRecreateView(changes) {
+        const ctxChange = changes["context"];
+        const aCtxChange = changes["additionalContext"];
+        return !!changes["ngxTemplateOutlet"]
+            || (ctxChange && NgxTemplateOutletDirective.hasContextShapeChanged(ctxChange))
+            || (aCtxChange && NgxTemplateOutletDirective.hasContextShapeChanged(aCtxChange));
+    }
+    updateExistingContext(ctx, context) {
+        if (!ctx)
+            return;
+        let ctxProto = Object.getPrototypeOf(ctx);
+        if (ctxProto == Object.prototype) {
+            ctxProto = ctx;
+        }
+        const props = Object.getOwnPropertyNames(ctxProto);
+        for (const propName of props) {
+            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);
+            // Copy if its a getter and it is not $implicit
+            if (desc.get && propName !== "$implicit") {
+                Object.defineProperty(context, propName, desc);
+                continue;
+            }
+            const func = ObjectUtils.isFunction(desc.value) ? desc.value.bind(ctx) : null;
+            if (func && func !== ctxProto.constructor) {
+                context[propName] = func;
+            }
+        }
+        for (const propName of Object.keys(ctx)) {
+            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);
+            if (desc && desc.get && !desc.set)
+                continue;
+            context[propName] = ctx[propName];
+        }
+    }
+}
+NgxTemplateOutletDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[ngxTemplateOutlet]"
+            },] }
+];
+NgxTemplateOutletDirective.ctorParameters = () => [
+    { type: ViewContainerRef }
+];
+NgxTemplateOutletDirective.propDecorators = {
+    context: [{ type: Input }],
+    additionalContext: [{ type: Input }],
+    ngxTemplateOutlet: [{ type: Input }]
+};
+
+class PaginationDirective {
+    constructor(zone) {
+        this.zone = zone;
+        this.pageChange = new EventEmitter();
+        this.onRefresh = new EventEmitter();
+        this.updateTimer = TimerUtils.createTimeout(() => this.loadData(), this.updateTime);
+    }
+    get total() {
+        return this.data ? this.data.total : 0;
+    }
+    get items() {
+        return this.data ? this.data.items : [];
+    }
+    ngOnChanges(changes) {
+        if (!changes.loader && !changes.itemsPerPage && !changes.page)
+            return;
+        this.page = isNaN(this.page) || this.page < 1 ? 1 : this.page;
+        this.itemsPerPage = isNaN(this.itemsPerPage) || this.itemsPerPage < 1 ? 20 : this.itemsPerPage;
+        this.updateTimer.time = isNaN(this.updateTime) || this.updateTime < 0 ? 100 : this.updateTime;
+        this.waitFor = this.waitFor || Promise.resolve(true);
+        this.refresh();
+    }
+    refresh() {
+        this.waitFor.then(() => {
+            this.updateTimer.run();
+        });
+    }
+    paginate(page) {
+        this.page = page;
+        this.pageChange.emit(page);
+        this.refresh();
+    }
+    loadData() {
+        if (!this.loader)
+            return;
+        this.loader(this.page, this.itemsPerPage).then(data => {
+            this.maxPage = !data || data.total <= 0 ? 1 : Math.floor((data.total - 1) / this.itemsPerPage) + 1;
+            this.data = data;
+            const baseIndex = (this.page - 1) * this.itemsPerPage;
+            const items = (data.items || []);
+            data.items = items.map((item, index) => {
+                const ix = baseIndex + index;
+                return item instanceof PaginationItemContext
+                    ? item
+                    : new PaginationItemContext(item, items, items.length, index, ix);
+            });
+            if (this.page > this.maxPage) {
+                this.paginate(this.maxPage);
+                return;
+            }
+            this.zone.run(() => this.onRefresh.emit(this));
+        });
+    }
+}
+PaginationDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[pagination]",
+                exportAs: "pagination"
+            },] }
+];
+PaginationDirective.ctorParameters = () => [
+    { type: NgZone }
+];
+PaginationDirective.propDecorators = {
+    loader: [{ type: Input, args: ["pagination",] }],
+    page: [{ type: Input }],
+    itemsPerPage: [{ type: Input }],
+    updateTime: [{ type: Input }],
+    waitFor: [{ type: Input }],
+    pageChange: [{ type: Output }],
+    onRefresh: [{ type: Output }]
+};
+
+class PaginationItemDirective {
+    constructor(pagination, viewContainer, templateRef) {
+        this.pagination = pagination;
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+    }
+    ngOnInit() {
+        this.onRefresh = this.pagination.onRefresh.subscribe(() => this.renderView());
+    }
+    ngOnDestroy() {
+        this.onRefresh.unsubscribe();
+    }
+    renderView() {
+        this.viewContainer.clear();
+        this.pagination.items.forEach((item) => {
+            item.$implicit = item;
+            this.viewContainer.createEmbeddedView(this.templateRef, item);
+        });
+    }
+}
+PaginationItemDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[paginationItem]"
+            },] }
+];
+PaginationItemDirective.ctorParameters = () => [
+    { type: PaginationDirective },
+    { type: ViewContainerRef },
+    { type: TemplateRef }
+];
+
+class ResourceIfDirective {
+    constructor(http, viewContainer, templateRef, universal) {
+        this.http = http;
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        this.universal = universal;
+        this.context = new ResourceIfContext();
+    }
+    set resourceIf(resource) {
+        this.resource = resource;
+        this.renderView();
+    }
+    get resourceIf() {
+        return this.resource;
+    }
+    get url() {
+        return this.context.url;
+    }
+    renderView() {
+        this.context = new ResourceIfContext();
+        this.context.resource = this.resource;
+        this.viewContainer.clear();
+        if (this.universal.isBrowser && this.resource) {
+            FileUtils.readDataFromUrl(this.http, this.resource).then(url => {
+                this.context.url = url;
+                this.viewContainer.createEmbeddedView(this.templateRef, this.context);
+            }, console.log);
+        }
+    }
+}
+ResourceIfDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[resourceIf]",
+                exportAs: "resourceIf"
+            },] }
+];
+ResourceIfDirective.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: UniversalService }
+];
+ResourceIfDirective.propDecorators = {
+    resourceIf: [{ type: Input }]
+};
+
+class StickyDirective {
+    constructor(cdr, events, element) {
+        this.cdr = cdr;
+        this.events = events;
+        this.element = element;
+        this.parentElement = this.element.nativeElement.parentElement;
+        this.updateTimer = TimerUtils.createTimeout(() => {
+            this.isUpdating = false;
+            this.cdr.detectChanges();
+            this.events.updateSticky(this.isSticky);
+        }, 10);
+    }
+    ngOnInit() {
+        this.eventForwarded = this.events.eventForwarded.subscribe((e) => {
+            if (e && e.type === "scroll")
+                this.updateSticky();
+        });
+    }
+    ngOnDestroy() {
+        this.eventForwarded.unsubscribe();
+    }
+    updateSticky() {
+        const distanceToTop = this.parentElement.getBoundingClientRect().top;
+        this.isSticky = distanceToTop < 1;
+        this.isUpdating = true;
+        this.cdr.detectChanges();
+        this.updateTimer.run();
+    }
+}
+StickyDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[sticky]"
+            },] }
+];
+StickyDirective.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: EventsService },
+    { type: ElementRef }
+];
+StickyDirective.propDecorators = {
+    isSticky: [{ type: HostBinding, args: ["class.sticky",] }],
+    isUpdating: [{ type: HostBinding, args: ["class.sticky-update",] }],
+    updateSticky: [{ type: HostListener, args: ["window:resize",] }, { type: HostListener, args: ["window:scroll",] }]
+};
+
+class UnorderedListItemDirective {
+    constructor(elementRef, renderer, viewContainer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.viewContainer = viewContainer;
+    }
+    get elem() {
+        return this.elementRef.nativeElement;
+    }
+    ngOnChanges(changes) {
+        if (!this.templates || !this.defaultTemplates || !this.item)
+            return;
+        const promise = this.item.value instanceof Promise ? this.item.value : Promise.resolve(this.item.value);
+        promise.then(value => {
+            this.item.value = value;
+            this.path = ObjectUtils.isNullOrUndefined(this.path) ? "" : this.path.toString();
+            this.isArray = ObjectUtils.isArray(this.data);
+            this.isObject = ObjectUtils.isObject(this.data);
+            this.valueIsArray = ObjectUtils.isArray(this.item.value);
+            this.valueIsObject = ObjectUtils.isObject(this.item.value);
+            this.valueType = ObjectUtils.getType(this.item.value);
+            const context = this;
+            const template = this.templates.find(t => t.type == this.type && ObjectUtils.evaluate(t.selector, context)) || this.defaultTemplates[this.type];
+            // Set view
+            this.viewContainer.clear();
+            this.viewContainer.createEmbeddedView(template, context);
+            // Set classes
+            if (this.type !== "item")
+                return;
+            this.item.classList = [];
+            this.isClass("is-array", this.valueIsArray);
+            this.isClass("is-object", this.valueIsObject);
+            this.isClass("is-value", !this.valueIsObject && !this.valueIsArray);
+            this.isClass(`type-${this.valueType}`);
+            this.isClass(`path-${this.path.replace(/\./g, "-")}`);
+            this.isClass(`key-${this.item.key}`);
+        }, reason => {
+            console.log("Can't handle promise rejection", reason);
+        });
+    }
+    isClass(className, value = true) {
+        if (!value)
+            return;
+        this.item.classList.push(className);
+    }
+}
+UnorderedListItemDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[unorderedListItem]"
+            },] }
+];
+UnorderedListItemDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: ViewContainerRef }
+];
+UnorderedListItemDirective.propDecorators = {
+    item: [{ type: Input, args: ["unorderedListItem",] }],
+    type: [{ type: Input }],
+    data: [{ type: Input }],
+    keyPrefix: [{ type: Input }],
+    listStyle: [{ type: Input }],
+    path: [{ type: Input }],
+    level: [{ type: Input }],
+    templates: [{ type: Input }],
+    defaultTemplates: [{ type: Input }]
+};
+
+class UnorderedListTemplateDirective extends UnorederedListTemplate {
+    constructor(elementRef, templateRef) {
+        super();
+        this.elementRef = elementRef;
+        this.templateRef = templateRef;
+    }
+    createEmbeddedView(context) {
+        return this.templateRef.createEmbeddedView(context);
+    }
+}
+UnorderedListTemplateDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "ng-template[type][selector]"
+            },] }
+];
+UnorderedListTemplateDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: TemplateRef }
+];
+UnorderedListTemplateDirective.propDecorators = {
+    type: [{ type: Input }],
+    selector: [{ type: Input }]
+};
+
+class UnorderedListComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this.keyPrefix = "";
+        this.listStyle = "table";
+        this.path = "";
+        this.level = 0;
+    }
+    ngOnChanges(changes) {
+        this.isArray = ObjectUtils.isArray(this.data);
+        this.isObject = ObjectUtils.isObject(this.data);
+    }
+    ngAfterContentInit() {
+        const templates = this.templateDirectives.toArray();
+        this.templates = this.templates ? this.templates.concat(templates) : templates;
+        this.cdr.detectChanges();
+    }
+    ngAfterViewInit() {
+        this.defaultTemplates = {
+            key: this.defaultKeyTemplate,
+            value: this.defaultValueTemplate,
+            item: this.defaultItemTemplate
+        };
+        this.cdr.detectChanges();
+    }
+}
+UnorderedListComponent.decorators = [
+    { type: Component, args: [{
+                selector: "unordered-list",
+                template: "<ng-template let-keyPrefix=\"keyPrefix\" let-key=\"item.key\" let-isArray=\"isArray\" #defaultKeyTemplate>\r\n    {{ (keyPrefix ? keyPrefix + key : key) | translate }}:\r\n</ng-template>\r\n<ng-template let-keyPrefix=\"keyPrefix\" let-listStyle=\"listStyle\" let-val=\"item.value\" let-path=\"path\"\r\n             let-templates=\"templates\" let-isObject=\"valueIsObject\" let-isArray=\"valueIsArray\" #defaultValueTemplate>\r\n    <ng-template #value>\r\n        <span [innerHTML]=\"val\"></span>\r\n    </ng-template>\r\n    <unordered-list [data]=\"val\"\r\n                    [keyPrefix]=\"keyPrefix\"\r\n                    [listStyle]=\"listStyle\"\r\n                    [path]=\"path\"\r\n                    [level]=\"level + 1\"\r\n                    [templates]=\"templates\"\r\n                    *ngIf=\"(isObject || isArray); else value\"></unordered-list>\r\n</ng-template>\r\n<ng-template let-item=\"item\" let-data=\"data\" let-keyPrefix=\"keyPrefix\" let-listStyle=\"listStyle\" let-path=\"path\" let-level=\"level\" let-templates=\"templates\" #defaultItemTemplate>\r\n    <ng-template #itemKey>\r\n        <ng-container [unorderedListItem]=\"item\"\r\n                      type=\"key\"\r\n                      [data]=\"data\"\r\n                      [keyPrefix]=\"keyPrefix\"\r\n                      [listStyle]=\"listStyle\"\r\n                      [path]=\"path\"\r\n                      [level]=\"level\"\r\n                      [templates]=\"templates\"\r\n                      [defaultTemplates]=\"defaultTemplates\"></ng-container>\r\n    </ng-template>\r\n    <ng-template #itemValue>\r\n        <ng-container [unorderedListItem]=\"item\"\r\n                      type=\"value\"\r\n                      [data]=\"data\"\r\n                      [keyPrefix]=\"keyPrefix\"\r\n                      [listStyle]=\"listStyle\"\r\n                      [path]=\"path\"\r\n                      [level]=\"level\"\r\n                      [templates]=\"templates\"\r\n                      [defaultTemplates]=\"defaultTemplates\"></ng-container>\r\n    </ng-template>\r\n    <ng-container *ngIf=\"!isArray\">\r\n        <th *ngIf=\"listStyle == 'table'; else itemKey\">\r\n            <ng-container [ngTemplateOutlet]=\"itemKey\"></ng-container>\r\n        </th>\r\n    </ng-container>\r\n    <td *ngIf=\"listStyle == 'table'; else itemValue\">\r\n        <ng-container [ngTemplateOutlet]=\"itemValue\"></ng-container>\r\n    </td>\r\n</ng-template>\r\n<ng-template #value>\r\n    <span [innerHTML]=\"data\"></span>\r\n</ng-template>\r\n<ng-container *ngIf=\"(isObject || isArray); else value\" [ngSwitch]=\"listStyle\">\r\n    <ul [ngClass]=\"'level-' + level\" *ngSwitchCase=\"'list'\">\r\n        <li *ngFor=\"let item of data | entries\" [ngClass]=\"item.classList\">\r\n            <ng-container [unorderedListItem]=\"item\"\r\n                          type=\"item\"\r\n                          [data]=\"data\"\r\n                          [keyPrefix]=\"keyPrefix\"\r\n                          [listStyle]=\"listStyle\"\r\n                          [path]=\"path ? path + '.' + item.key : item.key\"\r\n                          [level]=\"level\"\r\n                          [templates]=\"templates\"\r\n                          [defaultTemplates]=\"defaultTemplates\"></ng-container>\r\n        </li>\r\n    </ul>\r\n    <table [ngClass]=\"'level-' + level\" *ngSwitchDefault>\r\n        <tr *ngFor=\"let item of data | entries\" [ngClass]=\"item.classList\">\r\n            <ng-container [unorderedListItem]=\"item\"\r\n                          type=\"item\"\r\n                          [data]=\"data\"\r\n                          [keyPrefix]=\"keyPrefix\"\r\n                          [listStyle]=\"listStyle\"\r\n                          [path]=\"path ? path + '.' + item.key : item.key\"\r\n                          [level]=\"level\"\r\n                          [templates]=\"templates\"\r\n                          [defaultTemplates]=\"defaultTemplates\"></ng-container>\r\n        </tr>\r\n    </table>\r\n</ng-container>\r\n"
+            },] }
+];
+UnorderedListComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+UnorderedListComponent.propDecorators = {
+    data: [{ type: Input }],
+    keyPrefix: [{ type: Input }],
+    listStyle: [{ type: Input }],
+    path: [{ type: Input }],
+    level: [{ type: Input }],
+    templates: [{ type: Input }],
+    templateDirectives: [{ type: ContentChildren, args: [UnorderedListTemplateDirective,] }],
+    defaultKeyTemplate: [{ type: ViewChild, args: ["defaultKeyTemplate",] }],
+    defaultValueTemplate: [{ type: ViewChild, args: ["defaultValueTemplate",] }],
+    defaultItemTemplate: [{ type: ViewChild, args: ["defaultItemTemplate",] }]
+};
+
+class DynamicTableComponent {
+    constructor() {
+        this.loadData = (page, itemsPerPage) => {
+            const orderBy = this.orders[this.orderBy];
+            return this.dataLoader(page, itemsPerPage, orderBy, this.orderDescending, this.filter);
+        };
+        this.dataLoader = this.loadLocalData;
+        this.placeholder = "";
+        this.tableId = UniqueUtils.uuid();
+        this.templates = {};
+        this.filter = "";
+        this.orders = {};
+    }
+    get items() {
+        return !this.pagination ? [] : this.pagination.items;
+    }
+    static compare(orderBy, a, b) {
+        a = a.item ? a.item[orderBy] : null;
+        b = b.item ? b.item[orderBy] : null;
+        return ObjectUtils.compare(a, b);
+    }
+    ngAfterContentInit() {
+        this.templates = this.templateDirectives.reduce((result, directive) => {
+            if (ObjectUtils.isArray(directive.column)) {
+                directive.column.forEach(column => {
+                    result[column] = directive;
+                });
+                return result;
+            }
+            if (!ObjectUtils.isString(directive.column) || directive.column.length == 0)
+                return result;
+            result[directive.column] = directive;
+            return result;
+        }, {});
+    }
+    ngAfterViewInit() {
+        this.rowTemplate = this.rowTemplate || this.defaultRowTemplate;
+        this.filterTemplate = this.filterTemplate || this.defaultFilterTemplate;
+    }
+    ngOnChanges(changes) {
+        if (changes.columns) {
+            const columns = changes.columns.currentValue || [];
+            this.orders = ObjectUtils.isArray(columns) ? columns.reduce((result, column) => {
+                result[column] = column;
+                return result;
+            }, {}) : columns;
+            this.cols = Object.keys(this.orders);
+            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];
+        }
+        if (changes.orderBy && this.orders) {
+            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];
+        }
+        if (!changes.data && !changes.parallelData && !changes.itemsPerPage && !changes.orderBy && !changes.orderDescending)
+            return;
+        this.refresh();
+    }
+    refresh() {
+        if (!this.pagination)
+            return;
+        this.pagination.refresh();
+    }
+    setFilter(filter) {
+        this.filter = filter;
+        this.refresh();
+    }
+    setOrder(column) {
+        this.orderDescending = column == this.orderBy && !this.orderDescending;
+        this.orderBy = column;
+        this.refresh();
+    }
+    loadLocalData(page, rowsPerPage, orderBy, orderDescending, filter) {
+        if (!this.data) {
+            return Promise.resolve({
+                total: 0,
+                items: []
+            });
+        }
+        const compare = orderDescending
+            ? (a, b) => DynamicTableComponent.compare(orderBy, b, a)
+            : (a, b) => DynamicTableComponent.compare(orderBy, a, b);
+        const from = (page - 1) * rowsPerPage;
+        const dataLength = this.data.length;
+        const length = Math.min(rowsPerPage, dataLength - from);
+        const parallelData = this.parallelData || [];
+        let data = this.data.map((item, ix) => {
+            return new PaginationItemContext(item, parallelData[ix] || {}, dataLength, ix, ix);
+        });
+        if (ObjectUtils.isString(filter) && filter.length > 0) {
+            const filterRx = new RegExp(filter, "gi");
+            data = data.filter(c => c.filter(filterRx));
+        }
+        const items = orderBy ? data.sort(compare).splice(from, length) : data.splice(from, length);
+        items.forEach((context, ix) => {
+            context.index = from + ix;
+        });
+        return Promise.resolve({
+            total: dataLength,
+            items: items
+        });
+    }
+}
+DynamicTableComponent.decorators = [
+    { type: Component, args: [{
+                selector: "dynamic-table",
+                template: "<div class=\"dynamic-table\" #pagination=\"pagination\" [pagination]=\"loadData\" [itemsPerPage]=\"itemsPerPage\" [updateTime]=\"updateTime\">\r\n    <ng-template #defaultFilterTemplate let-table>\r\n        <div class=\"table-search\" *ngIf=\"table.showFilter\">\r\n            <label *ngIf=\"label\" [attr.for]=\"tableId\">{{ label | translate }}</label>\r\n            <input type=\"text\"\r\n                   class=\"form-control\"\r\n                   [attr.id]=\"tableId\"\r\n                   [placeholder]=\"placeholder | translate\"\r\n                   [ngModel]=\"table.filter\"\r\n                   (ngModelChange)=\"table.setFilter($event)\"/>\r\n        </div>\r\n    </ng-template>\r\n    <ng-container [ngxTemplateOutlet]=\"filterTemplate || defaultFilterTemplate\" [context]=\"this\"></ng-container>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n    <div class=\"table-responsive\">\r\n\r\n        <ng-template #columnTemplate let-context let-column=\"column\" let-template=\"template\">\r\n            <ng-template #defaultTemplate let-column=\"column\" let-item=\"item\">\r\n                <span>{{ item[column] == undefined || item[column] == null ? '-' : item[column] }}</span>\r\n            </ng-template>\r\n            <ng-template #pureTemplate>\r\n                <ng-container [ngxTemplateOutlet]=\"template.ref\" [context]=\"context\"></ng-container>\r\n            </ng-template>\r\n            <td [ngClass]=\"'column-' + column\" *ngIf=\"!template || !template.pure; else pureTemplate\">\r\n                <ng-container [ngxTemplateOutlet]=\"!template ? defaultTemplate : template.ref\" [context]=\"context\"></ng-container>\r\n            </td>\r\n        </ng-template>\r\n\r\n        <ng-template #columnsTemplate let-context>\r\n            <ng-container *ngFor=\"let column of cols\"\r\n                          [ngxTemplateOutlet]=\"columnTemplate\"\r\n                          [context]=\"context\"\r\n                          [additionalContext]=\"{\r\n                            template: templates[column],\r\n                            column: column\r\n                          }\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultRowTemplate let-context>\r\n            <tr>\r\n                <ng-container [ngxTemplateOutlet]=\"columnsTemplate\" [context]=\"context\"></ng-container>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultWrapperTemplate>\r\n            <table class=\"table table-striped\">\r\n                <thead>\r\n                <tr>\r\n                    <th *ngFor=\"let column of cols\" [ngClass]=\"'column-' + column\">\r\n                        <a *ngIf=\"orders[column]\" (click)=\"setOrder(column)\">\r\n                            <span>{{ 'label.' + column | translate }}</span>\r\n                            <i *ngIf=\"orderBy == column\"\r\n                               [icon]=\"orderDescending ? 'sort-desc' : 'sort-asc'\"\r\n                               [ngClass]=\"orderBy == column ? (orderDescending ? 'sort-desc': 'sort-asc') : ''\"></i>\r\n                        </a>\r\n                        <span *ngIf=\"!orders[column]\">{{ 'label.' + column | translate }}</span>\r\n                    </th>\r\n                </tr>\r\n                </thead>\r\n                <tbody>\r\n                <ng-container *paginationItem=\"let context\"\r\n                              [ngxTemplateOutlet]=\"rowTemplate\"\r\n                              [context]=\"context\"\r\n                              [additionalContext]=\"this\"></ng-container>\r\n                </tbody>\r\n            </table>\r\n        </ng-template>\r\n\r\n        <ng-container [ngxTemplateOutlet]=\"wrapperTemplate || defaultWrapperTemplate\"\r\n                      [context]=\"this\"></ng-container>\r\n    </div>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n</div>\r\n"
+            },] }
+];
+DynamicTableComponent.ctorParameters = () => [];
+DynamicTableComponent.propDecorators = {
+    label: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    dataLoader: [{ type: Input }],
+    data: [{ type: Input }],
+    parallelData: [{ type: Input }],
+    columns: [{ type: Input }],
+    showFilter: [{ type: Input }],
+    itemsPerPage: [{ type: Input }],
+    updateTime: [{ type: Input }],
+    maxPages: [{ type: Input }],
+    directionLinks: [{ type: Input }],
+    boundaryLinks: [{ type: Input }],
+    orderBy: [{ type: Input }],
+    orderDescending: [{ type: Input }],
+    rowTemplate: [{ type: ContentChild, args: ["rowTemplate", { static: true },] }],
+    wrapperTemplate: [{ type: ContentChild, args: ["wrapperTemplate", { static: true },] }],
+    filterTemplate: [{ type: ContentChild, args: ["filterTemplate", { static: true },] }],
+    columnsTemplate: [{ type: ViewChild, args: ["columnsTemplate", { static: true },] }],
+    defaultRowTemplate: [{ type: ViewChild, args: ["defaultRowTemplate", { static: true },] }],
+    defaultWrapperTemplate: [{ type: ViewChild, args: ["defaultWrapperTemplate", { static: true },] }],
+    defaultFilterTemplate: [{ type: ViewChild, args: ["defaultFilterTemplate", { static: true },] }],
+    pagination: [{ type: ViewChild, args: ["pagination",] }],
+    templateDirectives: [{ type: ContentChildren, args: [DynamicTableTemplateDirective,] }]
+};
+
+class PaginationMenuComponent {
+    constructor(state, pagination, icons) {
+        this.state = state;
+        this.pagination = pagination;
+        this.icons = icons;
+        this.maxSize = 5;
+        this.directionLinks = true;
+        this.boundaryLinks = true;
+        this.firstLabel = `<<`;
+        this.prevLabel = `<`;
+        this.nextLabel = `>`;
+        this.lastLabel = `>>`;
+    }
+    get hasPrev() {
+        return this.pagination.page > 1;
+    }
+    get hasNext() {
+        return this.pagination.page < this.pagination.maxPage;
+    }
+    ngOnInit() {
+        this.onRefresh = this.pagination.onRefresh.subscribe(() => this.setPages());
+        this.setIcon("firstLabel", "first-page");
+        this.setIcon("prevLabel", "prev-page");
+        this.setIcon("nextLabel", "next-page");
+        this.setIcon("lastLabel", "last-page");
+    }
+    ngOnDestroy() {
+        if (!this.onRefresh)
+            return;
+        this.onRefresh.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        this.maxSize = isNaN(this.maxSize) || this.maxSize <= 0 ? 5 : this.maxSize;
+        this.directionLinks = ObjectUtils.isBoolean(this.directionLinks) ? this.directionLinks : true;
+        this.boundaryLinks = ObjectUtils.isBoolean(this.boundaryLinks) ? this.boundaryLinks : true;
+        this.setPages();
+    }
+    paginate(page) {
+        if (this.pagination.page == page || this.pagination.maxPage < page || page < 1)
+            return;
+        if (!this.urlParam) {
+            this.pagination.paginate(page);
+            return;
+        }
+        const params = Object.assign({}, this.state.params);
+        params[this.urlParam] = page.toString();
+        const path = StateService.toPath(this.state.route, params);
+        this.state.navigateByUrl(path);
+    }
+    setIcon(labelName, icon) {
+        this.icons.getIcon(icon, icon, false).then(i => {
+            if (i == icon)
+                return;
+            this[labelName] = i;
+        });
+    }
+    setPages() {
+        if (!this.pagination)
+            return;
+        const totalPages = this.pagination.maxPage;
+        let startPage = Math.max(this.pagination.page - Math.floor(this.maxSize / 2), 1);
+        let endPage = startPage + this.maxSize - 1;
+        if (endPage > totalPages) {
+            endPage = totalPages;
+            startPage = Math.max(endPage - this.maxSize + 1, 1);
+        }
+        const pages = [];
+        for (let num = startPage; num <= endPage; num++) {
+            pages.push(num);
+        }
+        this.pages = pages;
+    }
+}
+PaginationMenuComponent.decorators = [
+    { type: Component, args: [{
+                selector: "pagination-menu",
+                template: "<div class=\"pagination-menu\" *ngIf=\"pagination.total > pagination.itemsPerPage\">\r\n    <ul class=\"pagination\">\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(1)\" [innerHTML]=\"firstLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page - 1)\" [innerHTML]=\"prevLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{active: pagination.page == page}\" *ngFor=\"let page of pages\">\r\n            <a class=\"page-link\" [ngClass]=\"{active: pagination.page == page}\" (click)=\"paginate(page)\">{{ page }}</a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page + 1)\" [innerHTML]=\"nextLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.maxPage)\" [innerHTML]=\"lastLabel | safe\"></a>\r\n        </li>\r\n    </ul>\r\n</div>\r\n"
+            },] }
+];
+PaginationMenuComponent.ctorParameters = () => [
+    { type: StateService },
+    { type: PaginationDirective },
+    { type: undefined, decorators: [{ type: Inject, args: [ICON_SERVICE,] }] }
+];
+PaginationMenuComponent.propDecorators = {
+    maxSize: [{ type: Input }],
+    urlParam: [{ type: Input }],
+    directionLinks: [{ type: Input }],
+    boundaryLinks: [{ type: Input }]
+};
+
+class StickyClassDirective {
+    constructor(events, element, renderer) {
+        this.events = events;
+        this.element = element;
+        this.renderer = renderer;
+    }
+    ngOnInit() {
+        this.stickyUpdated = this.events.stickyUpdated.subscribe(() => {
+            if (this.events.isSticky) {
+                this.renderer.addClass(this.element.nativeElement, this.stickyClass || "sticky-sibling");
+                return;
+            }
+            this.renderer.removeClass(this.element.nativeElement, this.stickyClass || "sticky-sibling");
+        });
+    }
+    ngOnDestroy() {
+        this.stickyUpdated.unsubscribe();
+    }
+}
+StickyClassDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[stickyClass]"
+            },] }
+];
+StickyClassDirective.ctorParameters = () => [
+    { type: EventsService },
+    { type: ElementRef },
+    { type: Renderer2 }
+];
+StickyClassDirective.propDecorators = {
+    stickyClass: [{ type: Input }]
+};
+
+// --- Pipes ---
+const pipes = [
+    ChunkPipe,
+    EntriesPipe,
+    ExtraItemPropertiesPipe,
+    FilterPipe,
+    FindPipe,
+    FormatNumberPipe,
+    GetOffsetPipe,
+    GetTypePipe,
+    GlobalTemplatePipe,
+    GroupByPipe,
+    IsTypePipe,
+    JoinPipe,
+    KeysPipe,
+    MapPipe,
+    MaxPipe,
+    MinPipe,
+    PopPipe,
+    ReducePipe,
+    RemapPipe,
+    ReplacePipe,
+    ReversePipe,
+    RoundPipe,
+    SafeHtmlPipe,
+    ShiftPipe,
+    SplitPipe,
+    TranslatePipe,
+    ValuesPipe
+];
+// --- Directives ---
+const directives = [
+    AsyncMethodDirective,
+    BackgroundDirective,
+    DynamicTableTemplateDirective,
+    GlobalTemplateDirective,
+    IconDirective,
+    NgxTemplateOutletDirective,
+    PaginationDirective,
+    PaginationItemDirective,
+    ResourceIfDirective,
+    StickyDirective,
+    StickyClassDirective,
+    UnorderedListItemDirective,
+    UnorderedListTemplateDirective
+];
+// --- Components ---
+const components = [
+    DynamicTableComponent,
+    PaginationMenuComponent,
+    UnorderedListComponent
+];
+const providers = [
+    ...pipes,
+    BaseHttpClient,
+    BaseHttpService,
+    AuthGuard,
+    AclService,
+    ApiService,
+    StaticAuthService,
+    ConfigService,
+    ErrorHandlerService,
+    EventsService,
+    FormatterService,
+    GlobalTemplateService,
+    IconService,
+    LanguageService,
+    OpenApiService,
+    PromiseService,
+    StateService,
+    StaticLanguageService,
+    StorageService,
+    ConsoleToasterService,
+    TranslatedUrlSerializer,
+    UniversalService,
+    DeviceDetectorService,
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ResizeEventPlugin,
+        multi: true
+    },
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ScrollEventPlugin,
+        multi: true
+    },
+    {
+        provide: UrlSerializer,
+        useExisting: TranslatedUrlSerializer
+    },
+    {
+        provide: ErrorHandler,
+        useExisting: ErrorHandlerService
+    }
+];
+function loadConfig(config) {
+    return config.load;
+}
+class NgxUtilsModule {
+    static forRoot(config) {
+        return {
+            ngModule: NgxUtilsModule,
+            providers: [
+                ...providers,
+                {
+                    provide: API_SERVICE,
+                    useExisting: (!config ? null : config.apiService) || ApiService
+                },
+                {
+                    provide: AUTH_SERVICE,
+                    useExisting: (!config ? null : config.authService) || StaticAuthService
+                },
+                {
+                    provide: ICON_SERVICE,
+                    useExisting: (!config ? null : config.iconService) || IconService
+                },
+                {
+                    provide: LANGUAGE_SERVICE,
+                    useExisting: (!config ? null : config.languageService) || StaticLanguageService
+                },
+                {
+                    provide: TOASTER_SERVICE,
+                    useExisting: (!config ? null : config.toasterService) || ConsoleToasterService
+                },
+                {
+                    provide: PROMISE_SERVICE,
+                    useExisting: (!config ? null : config.promiseService) || PromiseService
+                },
+                {
+                    provide: CONFIG_SERVICE,
+                    useExisting: (!config ? null : config.configService) || ConfigService
+                },
+                {
+                    provide: GLOBAL_TEMPLATES,
+                    useExisting: (!config ? null : config.globalTemplates) || GlobalTemplateService
+                },
+                {
+                    provide: ROOT_ELEMENT,
+                    useValue: null
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: (!config ? null : config.initializeApp) || loadConfig,
+                    multi: true,
+                    deps: [(!config ? null : config.initializeApp) ? Injector : CONFIG_SERVICE]
+                }
+            ]
+        };
+    }
+}
+NgxUtilsModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    ...pipes,
+                    ...directives,
+                    ...components
+                ],
+                imports: [
+                    CommonModule,
+                    FormsModule
+                ],
+                exports: [
+                    ...pipes,
+                    ...directives,
+                    ...components,
+                    FormsModule
+                ],
+                providers: pipes
+            },] }
+];
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { API_SERVICE, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AuthGuard, BASE_CONFIG, BackgroundDirective, BaseHttpClient, BaseHttpService, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChunkPipe, Circle, ConfigService, ConsoleToasterService, DateUtils, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FileSystemEntry, FileUtils, FilterPipe, FindPipe, FormatNumberPipe, FormatterService, GLOBAL_TEMPLATES, GenericValue, GetOffsetPipe, GetTypePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_SERVICE, IConfiguration, IconDirective, IconService, Initializer, IsTypePipe, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UnorederedListTemplate, ValuedPromise, ValuesPipe, Vector, pipes as ɵa, directives as ɵb, components as ɵc, providers as ɵd, loadConfig as ɵe, StickyClassDirective as ɵf };
+//# sourceMappingURL=stemy-ngx-utils.js.map