@stemy/ngx-utils 12.1.2 → 13.0.1

package/esm2020/ngx-utils/utils/observable.utils.mjs

@@ -0,0 +1,63 @@
+import { from, Observable, Subject, Subscription } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+import { TimerUtils } from "./timer.utils";
+export 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);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/utils/reflect.utils.mjs

@@ -0,0 +1,33 @@
+import "reflect-metadata";
+import { ObjectUtils } from "./object.utils";
+export 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/utils/set.utils.mjs

@@ -0,0 +1,20 @@
+import { ObjectUtils } from "./object.utils";
+export 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));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy91dGlscy9zZXQudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBRTNDLE1BQU0sT0FBTyxRQUFRO0lBQ2pCLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBYSxFQUFFLEdBQVE7UUFDakMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQztZQUNsRCxPQUFPLEtBQUssQ0FBQztRQUNqQixJQUFJLEdBQUcsQ0FBQyxJQUFJLElBQUksR0FBRyxDQUFDLElBQUk7WUFDcEIsT0FBTyxLQUFLLENBQUM7UUFDakIsS0FBSyxNQUFNLElBQUksSUFBSSxHQUFHLEVBQUU7WUFDcEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDO2dCQUFFLE9BQU8sS0FBSyxDQUFDO1NBQ3BDO1FBQ0QsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUVELE1BQU0sQ0FBQyxRQUFRLENBQUMsR0FBYSxFQUFFLEtBQVk7UUFDdkMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztZQUFFLE9BQU87UUFDbkUsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNuQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09iamVjdFV0aWxzfSBmcm9tIFwiLi9vYmplY3QudXRpbHNcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBTZXRVdGlscyB7XHJcbiAgICBzdGF0aWMgZXF1YWxzKHNldDogU2V0PGFueT4sIG9iajogYW55KTogYm9vbGVhbiB7XHJcbiAgICAgICAgaWYgKCFPYmplY3RVdGlscy5pc1NldChzZXQpIHx8ICFPYmplY3RVdGlscy5pc1NldChvYmopKVxyXG4gICAgICAgICAgICByZXR1cm4gZmFsc2U7XHJcbiAgICAgICAgaWYgKHNldC5zaXplICE9IG9iai5zaXplKVxyXG4gICAgICAgICAgICByZXR1cm4gZmFsc2U7XHJcbiAgICAgICAgZm9yIChjb25zdCBpdGVtIGluIHNldCkge1xyXG4gICAgICAgICAgICBpZiAoIW9iai5oYXMoaXRlbSkpIHJldHVybiBmYWxzZTtcclxuICAgICAgICB9XHJcbiAgICAgICAgcmV0dXJuIHRydWU7XHJcbiAgICB9XHJcblxyXG4gICAgc3RhdGljIGFkZEFycmF5KHNldDogU2V0PGFueT4sIGl0ZW1zOiBhbnlbXSk6IHZvaWQge1xyXG4gICAgICAgIGlmICghT2JqZWN0VXRpbHMuaXNTZXQoc2V0KSB8fCAhT2JqZWN0VXRpbHMuaXNBcnJheShpdGVtcykpIHJldHVybjtcclxuICAgICAgICBpdGVtcy5mb3JFYWNoKGkgPT4gc2V0LmFkZChpKSk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/ngx-utils/utils/string.utils.mjs

@@ -0,0 +1,28 @@
+export 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) : "";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/utils/timer.utils.mjs

@@ -0,0 +1,52 @@
+import { ObjectUtils } from "./object.utils";
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/utils/unique.utils.mjs

@@ -0,0 +1,24 @@
+export 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/utils/vector.mjs

@@ -0,0 +1,77 @@
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vector.js","sourceRoot":"","sources":["../../../../src/ngx-utils/utils/vector.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,MAAM;IA6Bf,YAAmB,CAAS,EAAS,CAAS,EAAS,CAAS;QAA7C,MAAC,GAAD,CAAC,CAAQ;QAAS,MAAC,GAAD,CAAC,CAAQ;QAAS,MAAC,GAAD,CAAC,CAAQ;IAChE,CAAC;IA5BD,IAAI,QAAQ;QACR,OAAO,IAAI,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,MAAM;QACN,OAAO;YACH,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;YACjC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;SACvC,CAAC;IACN,CAAC;IAKD,GAAG,CAAC,CAAkB;QAClB,IAAI,CAAC,YAAY,MAAM;YAAE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;;YAChF,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,QAAQ,CAAC,CAAkB;QACvB,IAAI,CAAC,YAAY,MAAM;YAAE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;;YAChF,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,QAAQ,CAAC,CAAkB;QACvB,IAAI,CAAC,YAAY,MAAM;YAAE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;;YAChF,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,CAAkB;QACrB,IAAI,CAAC,YAAY,MAAM;YAAE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;;YAChF,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,CAAS;QACZ,OAAO,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,GAAG,CAAC,CAAS;QACT,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,CAAS;QACX,OAAO,IAAI,MAAM,CACb,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAC9B,CAAC;IACN,CAAC;IAED,OAAO,CAAC,CAAS;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,OAAO,CAAC,CAAU;QACd,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACrD,CAAC;IAED,KAAK;QACD,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,IAAI,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;QAChC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ","sourcesContent":["export class Vector {\r\n\r\n    get negative(): Vector {\r\n        return new Vector(-this.x, -this.y, -this.z);\r\n    }\r\n\r\n    get length(): number {\r\n        return Math.sqrt(this.dot(this));\r\n    }\r\n\r\n    get unit(): Vector {\r\n        return this.divide(this.length);\r\n    }\r\n\r\n    get min(): number {\r\n        return Math.min(Math.min(this.x, this.y), this.z);\r\n    }\r\n\r\n    get max(): number {\r\n        return Math.max(Math.max(this.x, this.y), this.z);\r\n    }\r\n\r\n    get angles(): any {\r\n        return {\r\n            theta: Math.atan2(this.z, this.x),\r\n            phi: Math.asin(this.y / this.length)\r\n        };\r\n    }\r\n\r\n    constructor(public x: number, public y: number, public z: number) {\r\n    }\r\n\r\n    add(v: Vector | number): Vector {\r\n        if (v instanceof Vector) return new Vector(this.x + v.x, this.y + v.y, this.z + v.z);\r\n        else return new Vector(this.x + v, this.y + v, this.z + v);\r\n    }\r\n\r\n    subtract(v: Vector | number): Vector {\r\n        if (v instanceof Vector) return new Vector(this.x - v.x, this.y - v.y, this.z - v.z);\r\n        else return new Vector(this.x - v, this.y - v, this.z - v);\r\n    }\r\n\r\n    multiply(v: Vector | number): Vector {\r\n        if (v instanceof Vector) return new Vector(this.x * v.x, this.y * v.y, this.z * v.z);\r\n        else return new Vector(this.x * v, this.y * v, this.z * v);\r\n    }\r\n\r\n    divide(v: Vector | number): Vector {\r\n        if (v instanceof Vector) return new Vector(this.x / v.x, this.y / v.y, this.z / v.z);\r\n        else return new Vector(this.x / v, this.y / v, this.z / v);\r\n    }\r\n\r\n    equals(v: Vector): boolean {\r\n        return this.x == v.x && this.y == v.y && this.z == v.z;\r\n    }\r\n\r\n    dot(v: Vector): number {\r\n        return this.x * v.x + this.y * v.y + this.z * v.z;\r\n    }\r\n\r\n    cross(v: Vector): Vector {\r\n        return new Vector(\r\n            this.y * v.z - this.z * v.y,\r\n            this.z * v.x - this.x * v.z,\r\n            this.x * v.y - this.y * v.x\r\n        );\r\n    }\r\n\r\n    angleTo(v: Vector): number {\r\n        return Math.acos(this.dot(v) / (this.length * v.length));\r\n    }\r\n\r\n    toArray(n?: number): number[] {\r\n        return [this.x, this.y, this.z].slice(0, n || 3);\r\n    }\r\n\r\n    clone(): Vector {\r\n        return new Vector(this.x, this.y, this.z);\r\n    }\r\n\r\n    init(x: number, y: number, z: number): Vector {\r\n        this.x = x;\r\n        this.y = y;\r\n        this.z = z;\r\n        return this;\r\n    }\r\n}\r\n"]}

package/esm2020/public_api.mjs

@@ -0,0 +1,85 @@
+export { CanvasColor, ICON_SERVICE, LANGUAGE_SERVICE, AUTH_SERVICE, PROMISE_SERVICE, StorageMode, TOASTER_SERVICE, UnorederedListTemplate, FactoryDependencies, PaginationItemContext, HttpPromise, EXPRESS_REQUEST, API_SERVICE, ResourceIfContext, IConfiguration, CONFIG_SERVICE, BASE_CONFIG, SCRIPT_PARAMS, ROOT_ELEMENT, ERROR_HANDLER, GLOBAL_TEMPLATES, ValuedPromise } from "./ngx-utils/common-types";
+export { AjaxRequestHandler } from "./ngx-utils/utils/ajax-request-handler";
+export { ObjectUtils } from "./ngx-utils/utils/object.utils";
+export { DateUtils } from "./ngx-utils/utils/date.utils";
+export { CanvasUtils } from "./ngx-utils/utils/canvas.utils";
+export { FileUtils } from "./ngx-utils/utils/file.utils";
+export { GenericValue } from "./ngx-utils/utils/generic-value";
+export { Rect, Circle, Point } from "./ngx-utils/utils/geometry";
+export { Initializer } from "./ngx-utils/utils/initializer";
+export { ReflectUtils } from "./ngx-utils/utils/reflect.utils";
+export { LoaderUtils } from "./ngx-utils/utils/loader.utils";
+export { MathUtils } from "./ngx-utils/utils/math.utils";
+export { AuthGuard } from "./ngx-utils/utils/auth.guard";
+export { ObservableUtils } from "./ngx-utils/utils/observable.utils";
+export { StringUtils } from "./ngx-utils/utils/string.utils";
+export { ArrayUtils } from "./ngx-utils/utils/array.utils";
+export { SetUtils } from "./ngx-utils/utils/set.utils";
+export { TimerUtils } from "./ngx-utils/utils/timer.utils";
+export { UniqueUtils } from "./ngx-utils/utils/unique.utils";
+export { Vector } from "./ngx-utils/utils/vector";
+export { UniversalService } from "./ngx-utils/services/universal.service";
+export { AclService } from "./ngx-utils/services/acl.service";
+export { ApiService } from "./ngx-utils/services/api.service";
+export { StaticAuthService } from "./ngx-utils/services/auth.service";
+export { BaseHttpClient } from "./ngx-utils/services/base-http.client";
+export { BaseHttpService } from "./ngx-utils/services/base-http.service";
+export { ConfigService } from "./ngx-utils/services/config.service";
+export { ErrorHandlerService } from "./ngx-utils/services/error-handler.service";
+export { EventsService } from "./ngx-utils/services/events.service";
+export { FormatterService } from "./ngx-utils/services/formatter.service";
+export { GlobalTemplateService } from "./ngx-utils/services/global-template.service";
+export { IconService } from "./ngx-utils/services/icon.service";
+export { LanguageService } from "./ngx-utils/services/language.service";
+export { OpenApiService } from "./ngx-utils/services/open-api.service";
+export { StateService } from "./ngx-utils/services/state.service";
+export { StaticLanguageService } from "./ngx-utils/services/static-language.service";
+export { StorageService } from "./ngx-utils/services/storage.service";
+export { ConsoleToasterService } from "./ngx-utils/services/toaster.service";
+export { TranslatedUrlSerializer } from "./ngx-utils/services/translated-url.serializer";
+export { PromiseService } from "./ngx-utils/services/promise.service";
+export { ResizeEventPlugin } from "./ngx-utils/plugins/resize-event.plugin";
+export { ScrollEventPlugin } from "./ngx-utils/plugins/scroll-event.plugin";
+export { ChunkPipe } from "./ngx-utils/pipes/chunk.pipe";
+export { EntriesPipe } from "./ngx-utils/pipes/entries.pipe";
+export { ExtraItemPropertiesPipe } from "./ngx-utils/pipes/extra-item-properties.pipe";
+export { FilterPipe } from "./ngx-utils/pipes/filter.pipe";
+export { FindPipe } from "./ngx-utils/pipes/find.pipe";
+export { FormatNumberPipe } from "./ngx-utils/pipes/format-number.pipe";
+export { GetOffsetPipe } from "./ngx-utils/pipes/get-offset.pipe";
+export { GetTypePipe } from "./ngx-utils/pipes/get-type.pipe";
+export { GlobalTemplatePipe } from "./ngx-utils/pipes/global-template.pipe";
+export { GroupByPipe } from "./ngx-utils/pipes/group-by.pipe";
+export { IsTypePipe } from "./ngx-utils/pipes/is-type.pipe";
+export { JoinPipe } from "./ngx-utils/pipes/join.pipe";
+export { KeysPipe } from "./ngx-utils/pipes/keys.pipe";
+export { MapPipe } from "./ngx-utils/pipes/map.pipe";
+export { MaxPipe } from "./ngx-utils/pipes/max.pipe";
+export { MinPipe } from "./ngx-utils/pipes/min.pipe";
+export { ReducePipe } from "./ngx-utils/pipes/reduce.pipe";
+export { RemapPipe } from "./ngx-utils/pipes/remap.pipe";
+export { ReplacePipe } from "./ngx-utils/pipes/replace.pipe";
+export { ReversePipe } from "./ngx-utils/pipes/reverse.pipe";
+export { RoundPipe } from "./ngx-utils/pipes/round.pipe";
+export { SafeHtmlPipe } from "./ngx-utils/pipes/safe-html.pipe";
+export { TranslatePipe } from "./ngx-utils/pipes/translate.pipe";
+export { ValuesPipe } from "./ngx-utils/pipes/values.pipe";
+export { AsyncMethodBase } from "./ngx-utils/directives/async-method.base";
+export { AsyncMethodDirective } from "./ngx-utils/directives/async-method.directive";
+export { BackgroundDirective } from "./ngx-utils/directives/background.directive";
+export { DynamicTableTemplateDirective } from "./ngx-utils/directives/dynamic-table-template.directive";
+export { GlobalTemplateDirective } from "./ngx-utils/directives/global-template.directive";
+export { IconDirective } from "./ngx-utils/directives/icon.directive";
+export { NgxTemplateOutletDirective } from "./ngx-utils/directives/ngx-template-outlet.directive";
+export { PaginationDirective } from "./ngx-utils/directives/pagination.directive";
+export { PaginationItemDirective } from "./ngx-utils/directives/pagination-item.directive";
+export { ResourceIfDirective } from "./ngx-utils/directives/resource-if.directive";
+export { StickyDirective } from "./ngx-utils/directives/sticky.directive";
+export { StickyClassDirective } from "./ngx-utils/directives/sticky-class.directive";
+export { UnorderedListItemDirective } from "./ngx-utils/directives/unordered-list-item.directive";
+export { UnorderedListTemplateDirective } from "./ngx-utils/directives/unordered-list-template.directive";
+export { UnorderedListComponent } from "./ngx-utils/components/unordered-list/unordered-list.component";
+export { DynamicTableComponent } from "./ngx-utils/components/dynamic-table/dynamic-table.component";
+export { PaginationMenuComponent } from "./ngx-utils/components/pagination-menu/pagination-menu.component";
+export { NgxUtilsModule } from "./ngx-utils/ngx-utils.module";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../src/public_api.ts"],"names":[],"mappings":"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","sourcesContent":["export {\r\n    IResolveFactory,\r\n    CanvasColor,\r\n    IIconService,\r\n    ICON_SERVICE,\r\n    ITranslation,\r\n    ITranslations,\r\n    ILanguageSettings,\r\n    ILanguageService,\r\n    LANGUAGE_SERVICE,\r\n    IAuthService,\r\n    RouteValidator,\r\n    IRouteData,\r\n    IRoute,\r\n    AUTH_SERVICE,\r\n    IAclComponent,\r\n    IPromiseService,\r\n    PROMISE_SERVICE,\r\n    IRouteStateInfo,\r\n    NavigationUrlParam,\r\n    StorageMode,\r\n    IToasterService,\r\n    TOASTER_SERVICE,\r\n    IAsyncMessage,\r\n    AsyncMethod,\r\n    UnorederedListTemplate,\r\n    UnorderedListTemplates,\r\n    UnorderedListStyle,\r\n    IAjaxRequestDetails,\r\n    AjaxRequestCallback,\r\n    IScriptPromises,\r\n    IStylePromises,\r\n    ISearchObservable,\r\n    FactoryDependencies,\r\n    ITimer,\r\n    IExtraProperties,\r\n    IGroupMap,\r\n    TranslationQuery,\r\n    IPageInfo,\r\n    IPaginationData,\r\n    PaginationDataLoader,\r\n    PaginationItemContext,\r\n    IHttpHeaders,\r\n    IHttpParams,\r\n    IRequestOptions,\r\n    IIssueContext,\r\n    IProgress,\r\n    ProgressListener,\r\n    PromiseExecutor,\r\n    HttpPromise,\r\n    IHttpService,\r\n    EXPRESS_REQUEST,\r\n    IApiService,\r\n    API_SERVICE,\r\n    IOpenApiSchemaProperty,\r\n    IOpenApiSchema,\r\n    IOpenApiSchemas,\r\n    ITableColumns,\r\n    ITableTemplate,\r\n    ITableTemplates,\r\n    TableDataLoader,\r\n    ResourceIfContext,\r\n    IConfiguration,\r\n    IConfigService,\r\n    CONFIG_SERVICE,\r\n    BASE_CONFIG,\r\n    SCRIPT_PARAMS,\r\n    ROOT_ELEMENT,\r\n    ErrorHandlerCallback,\r\n    ERROR_HANDLER,\r\n    GlobalComponentModifier,\r\n    IGlobalTemplates,\r\n    GLOBAL_TEMPLATES,\r\n    AppInitializerFunc,\r\n    IModuleConfig,\r\n    ValuedPromise\r\n} from \"./ngx-utils/common-types\";\r\n\r\nexport {AjaxRequestHandler} from \"./ngx-utils/utils/ajax-request-handler\";\r\nexport {ObjectUtils} from \"./ngx-utils/utils/object.utils\";\r\nexport {DateUtils} from \"./ngx-utils/utils/date.utils\";\r\nexport {CanvasUtils} from \"./ngx-utils/utils/canvas.utils\";\r\nexport {FileUtils} from \"./ngx-utils/utils/file.utils\";\r\nexport {GenericValue} from \"./ngx-utils/utils/generic-value\";\r\nexport {IShape, Rect, Circle, Point} from \"./ngx-utils/utils/geometry\";\r\nexport {Initializer} from \"./ngx-utils/utils/initializer\";\r\nexport {ReflectUtils} from \"./ngx-utils/utils/reflect.utils\";\r\nexport {LoaderUtils} from \"./ngx-utils/utils/loader.utils\";\r\nexport {MathUtils} from \"./ngx-utils/utils/math.utils\";\r\nexport {AuthGuard} from \"./ngx-utils/utils/auth.guard\";\r\nexport {ObservableUtils, ISubscriberInfo} from \"./ngx-utils/utils/observable.utils\";\r\nexport {StringUtils} from \"./ngx-utils/utils/string.utils\";\r\nexport {ArrayUtils} from \"./ngx-utils/utils/array.utils\";\r\nexport {SetUtils} from \"./ngx-utils/utils/set.utils\";\r\nexport {TimerUtils} from \"./ngx-utils/utils/timer.utils\";\r\nexport {UniqueUtils} from \"./ngx-utils/utils/unique.utils\";\r\nexport {Vector} from \"./ngx-utils/utils/vector\";\r\n\r\nexport {UniversalService} from \"./ngx-utils/services/universal.service\";\r\nexport {AclService} from \"./ngx-utils/services/acl.service\";\r\nexport {ApiService} from \"./ngx-utils/services/api.service\";\r\nexport {StaticAuthService} from \"./ngx-utils/services/auth.service\";\r\nexport {BaseHttpClient} from \"./ngx-utils/services/base-http.client\";\r\nexport {BaseHttpService} from \"./ngx-utils/services/base-http.service\";\r\nexport {ConfigService} from \"./ngx-utils/services/config.service\";\r\nexport {ErrorHandlerService} from \"./ngx-utils/services/error-handler.service\";\r\nexport {EventsService} from \"./ngx-utils/services/events.service\";\r\nexport {FormatterService} from \"./ngx-utils/services/formatter.service\";\r\nexport {GlobalTemplateService} from \"./ngx-utils/services/global-template.service\";\r\nexport {IconService} from \"./ngx-utils/services/icon.service\";\r\nexport {LanguageService} from \"./ngx-utils/services/language.service\";\r\nexport {OpenApiService} from \"./ngx-utils/services/open-api.service\";\r\nexport {IStateInfo, StateService} from \"./ngx-utils/services/state.service\";\r\nexport {StaticLanguageService} from \"./ngx-utils/services/static-language.service\";\r\nexport {StorageService} from \"./ngx-utils/services/storage.service\";\r\nexport {ConsoleToasterService} from \"./ngx-utils/services/toaster.service\";\r\nexport {IUrlDictionary, TranslatedUrlSerializer} from \"./ngx-utils/services/translated-url.serializer\";\r\nexport {PromiseService} from \"./ngx-utils/services/promise.service\";\r\n\r\nexport {ResizeEventPlugin} from \"./ngx-utils/plugins/resize-event.plugin\";\r\nexport {ScrollEventPlugin} from \"./ngx-utils/plugins/scroll-event.plugin\";\r\n\r\nexport {ChunkPipe} from \"./ngx-utils/pipes/chunk.pipe\";\r\nexport {EntriesPipe} from \"./ngx-utils/pipes/entries.pipe\";\r\nexport {ExtraItemPropertiesPipe} from \"./ngx-utils/pipes/extra-item-properties.pipe\";\r\nexport {FilterPipe} from \"./ngx-utils/pipes/filter.pipe\";\r\nexport {FindPipe} from \"./ngx-utils/pipes/find.pipe\";\r\nexport {FormatNumberPipe} from \"./ngx-utils/pipes/format-number.pipe\";\r\nexport {GetOffsetPipe} from \"./ngx-utils/pipes/get-offset.pipe\";\r\nexport {GetTypePipe} from \"./ngx-utils/pipes/get-type.pipe\";\r\nexport {GlobalTemplatePipe} from \"./ngx-utils/pipes/global-template.pipe\";\r\nexport {GroupByPipe} from \"./ngx-utils/pipes/group-by.pipe\";\r\nexport {IsTypePipe} from \"./ngx-utils/pipes/is-type.pipe\";\r\nexport {JoinPipe} from \"./ngx-utils/pipes/join.pipe\";\r\nexport {KeysPipe} from \"./ngx-utils/pipes/keys.pipe\";\r\nexport {MapPipe} from \"./ngx-utils/pipes/map.pipe\";\r\nexport {MaxPipe} from \"./ngx-utils/pipes/max.pipe\";\r\nexport {MinPipe} from \"./ngx-utils/pipes/min.pipe\";\r\nexport {ReducePipe} from \"./ngx-utils/pipes/reduce.pipe\";\r\nexport {RemapPipe} from \"./ngx-utils/pipes/remap.pipe\";\r\nexport {ReplacePipe} from \"./ngx-utils/pipes/replace.pipe\";\r\nexport {ReversePipe} from \"./ngx-utils/pipes/reverse.pipe\";\r\nexport {RoundPipe} from \"./ngx-utils/pipes/round.pipe\";\r\nexport {SafeHtmlPipe} from \"./ngx-utils/pipes/safe-html.pipe\";\r\nexport {TranslatePipe} from \"./ngx-utils/pipes/translate.pipe\";\r\nexport {ValuesPipe} from \"./ngx-utils/pipes/values.pipe\";\r\n\r\nexport {AsyncMethodBase} from \"./ngx-utils/directives/async-method.base\";\r\nexport {AsyncMethodDirective} from \"./ngx-utils/directives/async-method.directive\";\r\nexport {BackgroundDirective} from \"./ngx-utils/directives/background.directive\";\r\nexport {DynamicTableTemplateDirective} from \"./ngx-utils/directives/dynamic-table-template.directive\";\r\nexport {GlobalTemplateDirective} from \"./ngx-utils/directives/global-template.directive\";\r\nexport {IconDirective} from \"./ngx-utils/directives/icon.directive\";\r\nexport {NgxTemplateOutletDirective} from \"./ngx-utils/directives/ngx-template-outlet.directive\";\r\nexport {PaginationDirective} from \"./ngx-utils/directives/pagination.directive\";\r\nexport {PaginationItemDirective} from \"./ngx-utils/directives/pagination-item.directive\";\r\nexport {ResourceIfDirective} from \"./ngx-utils/directives/resource-if.directive\";\r\nexport {StickyDirective} from \"./ngx-utils/directives/sticky.directive\";\r\nexport {StickyClassDirective} from \"./ngx-utils/directives/sticky-class.directive\";\r\nexport {UnorderedListItemDirective} from \"./ngx-utils/directives/unordered-list-item.directive\";\r\nexport {UnorderedListTemplateDirective} from \"./ngx-utils/directives/unordered-list-template.directive\";\r\n\r\nexport {UnorderedListComponent} from \"./ngx-utils/components/unordered-list/unordered-list.component\";\r\nexport {DynamicTableComponent} from \"./ngx-utils/components/dynamic-table/dynamic-table.component\";\r\nexport {PaginationMenuComponent} from \"./ngx-utils/components/pagination-menu/pagination-menu.component\";\r\n\r\nexport {NgxUtilsModule} from \"./ngx-utils/ngx-utils.module\";\r\n"]}

package/esm2020/stemy-ngx-utils.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlbXktbmd4LXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0ZW15LW5neC11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/fesm2015/stemy-ngx-utils.js

@@ -9,7 +9,6 @@ import { ActivatedRouteSnapshot, NavigationEnd, Router, DefaultUrlSerializer, Ur
 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 { parse } from 'json5';
 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';
@@ -2079,7 +2078,7 @@ class StorageService {
         this.universal = universal;
     }
     get(key, defaultValue, mode = StorageMode.Local) {
-        if (this.universal.isServer)
+        if (!this.universal.isBrowser)
             return defaultValue;
         const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
         const item = storage.getItem(key);
@@ -2093,7 +2092,7 @@ class StorageService {
         }
     }
     set(key, value, mode = StorageMode.Local) {
-        if (this.universal.isServer)
+        if (!this.universal.isBrowser)
             return;
         const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
         if (typeof value == "string") {
@@ -2103,7 +2102,7 @@ class StorageService {
         storage.setItem(key, JSON.stringify(value));
     }
     remove(key, mode = StorageMode.Local) {
-        if (this.universal.isServer)
+        if (!this.universal.isBrowser)
             return;
         const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
         storage.removeItem(key);
@@ -2437,6 +2436,7 @@ class StaticAuthService {
     }
 }
 
+const JSON5 = require("json5");
 class ConfigService {
     constructor(http, universal, rootElement, baseConfig = null, scriptParams = null) {
         this.http = http;
@@ -2503,7 +2503,7 @@ class ConfigService {
             const configUrl = this.configUrl;
             try {
                 const config5 = yield this.http.get(isDevMode() ? `${configUrl}5` : configUrl, { responseType: "text" }).toPromise();
-                return parse(config5);
+                return JSON5.parse(config5);
             }
             catch (e) {
                 try {
@@ -2532,7 +2532,7 @@ class ConfigService {
         return this.loadedConfig[key];
     }
     getQueryParameter(name, url) {
-        url = url || (this.universal.isServer ? "" : window.location.href);
+        url = url || (this.universal.isBrowser ? window.location.href : "");
         name = name.replace(/[\[\]]/g, "\\$&");
         const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"), results = regex.exec(url);
         if (!results)
@@ -2735,7 +2735,7 @@ class StaticLanguageService {
         this.initService();
     }
     get defaultLanguage() {
-        return this.configs.getQueryParameter("lang") || this.storage.get("language", this.browserLang);
+        return this.configs.getQueryParameter("lang") || this.storage.get("language", this.getDefaultLanguage());
     }
     get dictionary() {
         return this.translations[this.currentLanguage] || {};
@@ -2772,21 +2772,6 @@ class StaticLanguageService {
     get config() {
         return this.configs.config;
     }
-    get browserLang() {
-        if (this.universal.isServer || 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;
-    }
     get universal() {
         return this.storage.universal;
     }
@@ -2852,6 +2837,21 @@ class StaticLanguageService {
             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 }