@firestitch/common 8.0.10

package/bundles/firestitch-common.umd.js

@@ -0,0 +1,3548 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('lodash-es'), require('rxjs'), require('rxjs/operators')) :
+    typeof define === 'function' && define.amd ? define('@firestitch/common', ['exports', '@angular/core', '@angular/common', 'lodash-es', 'rxjs', 'rxjs/operators'], factory) :
+    (global = global || self, factory((global.firestitch = global.firestitch || {}, global.firestitch.common = {}), global.ng.core, global.ng.common, global.lodashEs, global.rxjs, global.rxjs.operators));
+}(this, (function (exports, core, common, lodashEs, rxjs, operators) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+                t[p[i]] = s[p[i]];
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+        if (m) return m.call(o);
+        return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/services/array.service.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsArray = /** @class */ (function () {
+        function FsArray() {
+        }
+        /**
+         * @deprecated use import { nameValue } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { nameValue } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} name
+         * @param {?} value
+         * @return {?}
+         */
+        FsArray.prototype.nameValue = /**
+         * @deprecated use import { nameValue } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} name
+         * @param {?} value
+         * @return {?}
+         */
+        function (array, name, value) {
+            console.warn('@deprecated use import { nameValue } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var list = [];
+            if (name || value) {
+                /** @type {?} */
+                var nameFn_1 = typeof name === 'function' ? name : (/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) { return item[name]; });
+                /** @type {?} */
+                var valueFn_1 = typeof value === 'function' ? value : (/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) { return item[value]; });
+                array.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) {
+                    list.push({ name: nameFn_1(item), value: valueFn_1(item) });
+                }));
+            }
+            else {
+                array.forEach((/**
+                 * @param {?} name
+                 * @param {?} value
+                 * @return {?}
+                 */
+                function (name, value) {
+                    list.push({ name: name, value: value });
+                }));
+            }
+            return list;
+        };
+        /**
+         * @deprecated use import { remove } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { remove } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        FsArray.prototype.remove = /**
+         * @deprecated use import { remove } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        function (array, query) {
+            console.warn('@deprecated use import { remove } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var idx = this.indexOf(array, query);
+            if (idx >= 0) {
+                return array.splice(idx, 1);
+            }
+            return idx;
+        };
+        /**
+         * @deprecated use import { indexOf } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { indexOf } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        FsArray.prototype.indexOf = /**
+         * @deprecated use import { indexOf } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        function (array, query) {
+            var _this = this;
+            console.warn('@deprecated use import { indexOf } from @firestitch/common/array; instead');
+            if (typeof query !== 'function') {
+                /** @type {?} */
+                var queryObj_1 = query;
+                query = (/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) {
+                    return _this.compare(queryObj_1, item);
+                });
+            }
+            for (var i = 0, len = array.length; i < len; i++) {
+                if (query(array[i])) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        /**
+         * @deprecated use import { compare } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { compare } from \@firestitch/common/array; instead
+         * @param {?} query
+         * @param {?} item
+         * @return {?}
+         */
+        FsArray.prototype.compare = /**
+         * @deprecated use import { compare } from \@firestitch/common/array; instead
+         * @param {?} query
+         * @param {?} item
+         * @return {?}
+         */
+        function (query, item) {
+            console.warn('@deprecated use import { compare } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var value = true;
+            for (var key in query) {
+                value = value && item[key] == query[key];
+            }
+            return value;
+        };
+        /**
+         * @deprecated use import { filter } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { filter } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        FsArray.prototype.filter = /**
+         * @deprecated use import { filter } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        function (array, query) {
+            var _this = this;
+            console.warn('@deprecated use import { filter } from @firestitch/common/array; instead');
+            if (typeof query !== 'function') {
+                /** @type {?} */
+                var queryObj_2 = query;
+                query = (/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) {
+                    return _this.compare(queryObj_2, item);
+                });
+            }
+            /** @type {?} */
+            var isarray = Array.isArray(array);
+            /** @type {?} */
+            var list = isarray ? [] : {};
+            if (isarray)
+                array.forEach((/**
+                 * @param {?} item
+                 * @param {?} idx
+                 * @return {?}
+                 */
+                function (item, idx) {
+                    if (query(item)) {
+                        list.push(item);
+                    }
+                }));
+            else
+                Object.keys(array).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                function (key) {
+                    if (query(array[key])) {
+                        list[key] = array[key];
+                    }
+                }));
+            return list;
+        };
+        /**
+         * @deprecated use import { index } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { index } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} property
+         * @return {?}
+         */
+        FsArray.prototype.index = /**
+         * @deprecated use import { index } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} property
+         * @return {?}
+         */
+        function (array, property) {
+            console.warn('@deprecated use import { index } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var list = {};
+            array.forEach((/**
+             * @param {?} item
+             * @param {?} idx
+             * @return {?}
+             */
+            function (item, idx) {
+                list[item[property]] = item;
+            }));
+            return list;
+        };
+        /**
+         * @deprecated use import { sort } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { sort } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @param {?=} reverse
+         * @return {?}
+         */
+        FsArray.prototype.sort = /**
+         * @deprecated use import { sort } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @param {?=} reverse
+         * @return {?}
+         */
+        function (array, query, reverse) {
+            if (reverse === void 0) { reverse = false; }
+            console.warn('@deprecated use import { sort } from @firestitch/common/array; instead');
+            if (typeof query !== 'function') {
+                /** @type {?} */
+                var queryStr_1 = query;
+                query = (/**
+                 * @param {?} a
+                 * @param {?} b
+                 * @return {?}
+                 */
+                function (a, b) {
+                    if (reverse) {
+                        if (a[queryStr_1] < b[queryStr_1]) {
+                            return 1;
+                        }
+                        else if (a[queryStr_1] > b[queryStr_1]) {
+                            return -1;
+                        }
+                    }
+                    else {
+                        if (a[queryStr_1] > b[queryStr_1]) {
+                            return 1;
+                        }
+                        else if (a[queryStr_1] < b[queryStr_1]) {
+                            return -1;
+                        }
+                    }
+                    return 0;
+                });
+            }
+            array.sort(query);
+            return array;
+        };
+        /**
+         * @deprecated use import { rsort } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { rsort } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        FsArray.prototype.rsort = /**
+         * @deprecated use import { rsort } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} query
+         * @return {?}
+         */
+        function (array, query) {
+            console.warn('@deprecated use import { rsort } from @firestitch/common/array; instead');
+            return this.sort(array, query, true);
+        };
+        /**
+         * @deprecated use import { list } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { list } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} property
+         * @param {?=} index
+         * @return {?}
+         */
+        FsArray.prototype.list = /**
+         * @deprecated use import { list } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} property
+         * @param {?=} index
+         * @return {?}
+         */
+        function (array, property, index) {
+            if (index === void 0) { index = null; }
+            console.warn('@deprecated use import { list } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var list = index ? {} : [];
+            array.forEach((/**
+             * @param {?} item
+             * @param {?} idx
+             * @return {?}
+             */
+            function (item, idx) {
+                if (index) {
+                    list[item[index]] = item[property];
+                }
+                else {
+                    list.push(item[property]);
+                }
+            }));
+            return list;
+        };
+        /**
+         * @deprecated use import { applyDepth } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { applyDepth } from \@firestitch/common/array; instead
+         * @param {?} objects
+         * @param {?} parent_property
+         * @param {?=} id_property
+         * @param {?=} depth_property
+         * @return {?}
+         */
+        FsArray.prototype.applyDepth = /**
+         * @deprecated use import { applyDepth } from \@firestitch/common/array; instead
+         * @param {?} objects
+         * @param {?} parent_property
+         * @param {?=} id_property
+         * @param {?=} depth_property
+         * @return {?}
+         */
+        function (objects, parent_property, id_property, depth_property) {
+            if (id_property === void 0) { id_property = 'id'; }
+            if (depth_property === void 0) { depth_property = 'depth'; }
+            console.warn('@deprecated use import { applyDepth } from @firestitch/common/array; instead');
+            /** @type {?} */
+            var keyed = {};
+            objects.forEach((/**
+             * @param {?} object
+             * @return {?}
+             */
+            function (object) {
+                if (!object[parent_property]) {
+                    object[depth_property] = 0;
+                }
+                keyed[object[id_property]] = object;
+            }));
+            Object.keys(keyed).forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            function (key) {
+                Object.keys(keyed).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                function (key) {
+                    /** @type {?} */
+                    var object = keyed[key];
+                    if (!keyed[key][depth_property]) {
+                        if (keyed[key][parent_property]) {
+                            keyed[key][depth_property] = keyed[keyed[key][parent_property]][depth_property] + 1;
+                        }
+                    }
+                }));
+            }));
+            return keyed;
+        };
+        /**
+         * @deprecated use import { inArray } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { inArray } from \@firestitch/common/array; instead
+         * @param {?} values
+         * @param {?} array
+         * @return {?}
+         */
+        FsArray.prototype.inArray = /**
+         * @deprecated use import { inArray } from \@firestitch/common/array; instead
+         * @param {?} values
+         * @param {?} array
+         * @return {?}
+         */
+        function (values, array) {
+            console.warn('@deprecated use import { inArray } from @firestitch/common/array; instead');
+            if (!Array.isArray(values)) {
+                values = [values];
+            }
+            for (var i = 0, len = values.length; i < len; i++) {
+                if (array.indexOf(values[i]) >= 0) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        /**
+         * @deprecated use import { keyExists } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { keyExists } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} key
+         * @return {?}
+         */
+        FsArray.prototype.keyExists = /**
+         * @deprecated use import { keyExists } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @param {?} key
+         * @return {?}
+         */
+        function (array, key) {
+            console.warn('@deprecated use import { keyExists } from @firestitch/common/array; instead');
+            return array.hasOwnProperty(key);
+        };
+        /**
+         * @deprecated use import { length } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { length } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @return {?}
+         */
+        FsArray.prototype.length = /**
+         * @deprecated use import { length } from \@firestitch/common/array; instead
+         * @param {?} array
+         * @return {?}
+         */
+        function (array) {
+            console.warn('@deprecated use import { length } from @firestitch/common/array; instead');
+            return array.length;
+        };
+        /**
+         * @deprecated use import { ksort } from @firestitch/common/array; instead
+        */
+        /**
+         * @deprecated use import { ksort } from \@firestitch/common/array; instead
+         * @param {?} unordered
+         * @return {?}
+         */
+        FsArray.prototype.ksort = /**
+         * @deprecated use import { ksort } from \@firestitch/common/array; instead
+         * @param {?} unordered
+         * @return {?}
+         */
+        function (unordered) {
+            console.warn('@deprecated use import { ksort } from @firestitch/common/array; instead');
+            Object.keys(unordered).sort().forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            function (key) {
+                /** @type {?} */
+                var value = unordered[key];
+                delete unordered[key];
+                unordered[key] = value;
+            }));
+        };
+        FsArray.decorators = [
+            { type: core.Injectable }
+        ];
+        return FsArray;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/services/math.service.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsMath = /** @class */ (function () {
+        function FsMath() {
+        }
+        /**
+         * @deprecated use _.round() instead {@link https://lodash.com/docs/4.17.5#round}
+        */
+        /**
+         * @deprecated use _.round() instead {\@link https://lodash.com/docs/4.17.5#round}
+         * @param {?} number
+         * @param {?} precision
+         * @return {?}
+         */
+        FsMath.prototype.round = /**
+         * @deprecated use _.round() instead {\@link https://lodash.com/docs/4.17.5#round}
+         * @param {?} number
+         * @param {?} precision
+         * @return {?}
+         */
+        function (number, precision) {
+            console.warn('@deprecated use _.round() instead {@link https://lodash.com/docs/4.17.5#round}');
+            precision = precision || 0;
+            /** @type {?} */
+            var factor = Math.pow(10, precision);
+            /** @type {?} */
+            var tempNumber = number * factor;
+            /** @type {?} */
+            var roundedTempNumber = Math.round(tempNumber);
+            return roundedTempNumber / factor;
+        };
+        FsMath.decorators = [
+            { type: core.Injectable }
+        ];
+        return FsMath;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/services/util.service.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var KEY_CANCEL = 3;
+    /** @type {?} */
+    var KEY_HELP = 6;
+    /** @type {?} */
+    var KEY_BACKSPACE = 8;
+    /** @type {?} */
+    var KEY_TAB = 9;
+    /** @type {?} */
+    var KEY_CLEAR = 12;
+    /** @type {?} */
+    var KEY_RETURN = 13;
+    /** @type {?} */
+    var KEY_ENTER = 14;
+    /** @type {?} */
+    var KEY_SHIFT = 16;
+    /** @type {?} */
+    var KEY_CONTROL = 17;
+    /** @type {?} */
+    var KEY_ALT = 18;
+    /** @type {?} */
+    var KEY_PAUSE = 19;
+    /** @type {?} */
+    var KEY_CAPS_LOCK = 20;
+    /** @type {?} */
+    var KEY_ESCAPE = 27;
+    /** @type {?} */
+    var KEY_SPACE = 32;
+    /** @type {?} */
+    var KEY_PAGE_UP = 33;
+    /** @type {?} */
+    var KEY_PAGE_DOWN = 34;
+    /** @type {?} */
+    var KEY_END = 35;
+    /** @type {?} */
+    var KEY_HOME = 36;
+    /** @type {?} */
+    var KEY_LEFT = 37;
+    /** @type {?} */
+    var KEY_UP = 38;
+    /** @type {?} */
+    var KEY_RIGHT = 39;
+    /** @type {?} */
+    var KEY_DOWN = 40;
+    /** @type {?} */
+    var KEY_PRINTSCREEN = 44;
+    /** @type {?} */
+    var KEY_INSERT = 45;
+    /** @type {?} */
+    var KEY_DELETE = 46;
+    /** @type {?} */
+    var KEY_0 = 48;
+    /** @type {?} */
+    var KEY_1 = 49;
+    /** @type {?} */
+    var KEY_2 = 50;
+    /** @type {?} */
+    var KEY_3 = 51;
+    /** @type {?} */
+    var KEY_4 = 52;
+    /** @type {?} */
+    var KEY_5 = 53;
+    /** @type {?} */
+    var KEY_6 = 54;
+    /** @type {?} */
+    var KEY_7 = 55;
+    /** @type {?} */
+    var KEY_8 = 56;
+    /** @type {?} */
+    var KEY_9 = 57;
+    /** @type {?} */
+    var KEY_SEMICOLON = 59;
+    /** @type {?} */
+    var KEY_EQUALS = 61;
+    /*
+        Basically, just copy-pasted functionality from fs-boilerplate v1.x, with some small changes (like we dont have angular.bind anymore, had to go with a workaround)
+        There might be a better way to organise constatns but I need to know use-cases
+    */
+    var FsUtil = /** @class */ (function () {
+        function FsUtil() {
+            this.intervals = {};
+        }
+        /**
+        * @deprecated use @firestitch/common/util/guid instead
+        */
+        /**
+         * @deprecated use \@firestitch/common/util/guid instead
+         * @param {?=} pattern
+         * @return {?}
+         */
+        FsUtil.prototype.guid = /**
+         * @deprecated use \@firestitch/common/util/guid instead
+         * @param {?=} pattern
+         * @return {?}
+         */
+        function (pattern) {
+            console.warn('@deprecated use @firestitch/common/util/guid instead');
+            pattern = pattern || 'xxxxxx';
+            return pattern.replace(/[xy]/g, (/**
+             * @param {?} c
+             * @return {?}
+             */
+            function (c) {
+                /** @type {?} */
+                var r = Math.random() * 16 | 0;
+                /** @type {?} */
+                var v = c == 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            }));
+        };
+        /**
+         * @deprecated use import { uuid } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { uuid } from \@firestitch/common/util; instead
+         * @return {?}
+         */
+        FsUtil.prototype.uuid = /**
+         * @deprecated use import { uuid } from \@firestitch/common/util; instead
+         * @return {?}
+         */
+        function () {
+            console.warn('@deprecated use @firestitch/common/util/uuid instead');
+            return this.guid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+        };
+        /**
+         * @deprecated use import { resolve } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { resolve } from \@firestitch/common/util; instead
+         * @param {?} promise
+         * @param {?=} defaults
+         * @return {?}
+         */
+        FsUtil.prototype.resolve = /**
+         * @deprecated use import { resolve } from \@firestitch/common/util; instead
+         * @param {?} promise
+         * @param {?=} defaults
+         * @return {?}
+         */
+        function (promise, defaults) {
+            if (defaults === void 0) { defaults = []; }
+            console.warn('@deprecated use @firestitch/common/util/resolve instead');
+            /** @type {?} */
+            var result = defaults;
+            return new Promise((/**
+             * @param {?} resolve
+             * @return {?}
+             */
+            function (resolve) {
+                promise.then((/**
+                 * @param {?} data
+                 * @return {?}
+                 */
+                function (data) {
+                    Object.keys(data).forEach((/**
+                     * @param {?} key
+                     * @return {?}
+                     */
+                    function (key) { return result[key] = data[key]; }));
+                    resolve(result);
+                }));
+            }));
+        };
+        /**
+         * @deprecated use _.toInteger() instead
+        */
+        /**
+         * @deprecated use _.toInteger() instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.int = /**
+         * @deprecated use _.toInteger() instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.toInteger() instead');
+            value = parseInt(value);
+            if (isNaN(value)) {
+                value = 0;
+            }
+            return value;
+        };
+        /**
+         * @deprecated use _.toFinite() instead
+        */
+        /**
+         * @deprecated use _.toFinite() instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.float = /**
+         * @deprecated use _.toFinite() instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.toFinite() instead');
+            value = parseFloat(value);
+            if (isNaN(value)) {
+                value = 0;
+            }
+            return value;
+        };
+        /**
+         * @deprecated use _.toString() instead
+        */
+        /**
+         * @deprecated use _.toString() instead
+         * @param {?} string
+         * @return {?}
+         */
+        FsUtil.prototype.string = /**
+         * @deprecated use _.toString() instead
+         * @param {?} string
+         * @return {?}
+         */
+        function (string) {
+            console.warn('@deprecated use _.toString() instead');
+            if (string === null || string === undefined) {
+                string = '';
+            }
+            return (string).toString();
+        };
+        /**
+         * @deprecated use import { isEmpty } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { isEmpty } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @param {?=} options
+         * @return {?}
+         */
+        FsUtil.prototype.isEmpty = /**
+         * @deprecated use import { isEmpty } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @param {?=} options
+         * @return {?}
+         */
+        function (value, options) {
+            console.warn('@deprecated use import { isEmpty } from @firestitch/common/util; instead');
+            options = options || {};
+            return value === undefined ||
+                value === null ||
+                value === false ||
+                value === '' ||
+                !this.string(value).length ||
+                (this.isObject(value) &&
+                    (value.constructor.name === 'Object' && !Object.keys(value).length)) ||
+                (!options.zero && (value === 0 || value === '0'));
+        };
+        /**
+         * @deprecated use _.isInteger() instead
+        */
+        /**
+         * @deprecated use _.isInteger() instead
+         * @param {?} value
+         * @param {?=} type
+         * @return {?}
+         */
+        FsUtil.prototype.isInt = /**
+         * @deprecated use _.isInteger() instead
+         * @param {?} value
+         * @param {?=} type
+         * @return {?}
+         */
+        function (value, type) {
+            console.warn('@deprecated use _.isInteger() instead');
+            /** @type {?} */
+            var int = !!this.string(value).match(/^\d+$/);
+            if (!int) {
+                return false;
+            }
+            if (type) {
+                return Number.isInteger(value);
+            }
+            return true;
+        };
+        /**
+         * @deprecated use _.each() instead {@link https://lodash.com/docs/4.17.5#forEach}
+        */
+        /**
+         * @deprecated use _.each() instead {\@link https://lodash.com/docs/4.17.5#forEach}
+         * @param {?} object
+         * @param {?} func
+         * @return {?}
+         */
+        FsUtil.prototype.each = /**
+         * @deprecated use _.each() instead {\@link https://lodash.com/docs/4.17.5#forEach}
+         * @param {?} object
+         * @param {?} func
+         * @return {?}
+         */
+        function (object, func) {
+            console.warn('@deprecated use _.each() instead {@link https://lodash.com/docs/4.17.5#forEach}');
+            if (!this.isArray(object) && !this.isObject(object)) {
+                return;
+            }
+            Object.keys(object).forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            function (key) {
+                func(object[key], key);
+            }));
+        };
+        /**
+         * @deprecated use _.isArrayLikeObject() {@link https://lodash.com/docs/4.17.5#isArrayLikeObject}
+         * or _.isObject() {@link https://lodash.com/docs/4.17.5#isObject} instead
+        */
+        /**
+         * @deprecated use _.isArrayLikeObject() {\@link https://lodash.com/docs/4.17.5#isArrayLikeObject}
+         * or _.isObject() {\@link https://lodash.com/docs/4.17.5#isObject} instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.isObject = /**
+         * @deprecated use _.isArrayLikeObject() {\@link https://lodash.com/docs/4.17.5#isArrayLikeObject}
+         * or _.isObject() {\@link https://lodash.com/docs/4.17.5#isObject} instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.isArrayLikeObject() {@link https://lodash.com/docs/4.17.5#isArrayLikeObject} or _.isObject() {@link https://lodash.com/docs/4.17.5#isObject} instead');
+            return value !== null && typeof value === 'object' && !this.isArray(value);
+        };
+        /**
+          * @deprecated use _.isString() instead {@link https://lodash.com/docs/4.17.5#isString}
+        */
+        /**
+         * @deprecated use _.isString() instead {\@link https://lodash.com/docs/4.17.5#isString}
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.isString = /**
+         * @deprecated use _.isString() instead {\@link https://lodash.com/docs/4.17.5#isString}
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.isString() instead {@link https://lodash.com/docs/4.17.5#isString}');
+            return typeof value === 'string' || value instanceof String;
+        };
+        /**
+         * @deprecated use _.isArray() instead {@link https://lodash.com/docs/4.17.5#isArray}
+        */
+        /**
+         * @deprecated use _.isArray() instead {\@link https://lodash.com/docs/4.17.5#isArray}
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.isArray = /**
+         * @deprecated use _.isArray() instead {\@link https://lodash.com/docs/4.17.5#isArray}
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.isArray() instead {@link https://lodash.com/docs/4.17.5#isArray}');
+            return value instanceof Array;
+        };
+        /**
+         * @deprecated use import { isNumeric } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { isNumeric } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.isNumeric = /**
+         * @deprecated use import { isNumeric } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use import { isNumeric } from @firestitch/common/util; instead');
+            return this.string(value).length && !!this.string(value).match(/^-?\d*\.?\d*$/);
+        };
+        /**
+         * @deprecated use import { isClass } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { isClass } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @param {?} cls
+         * @return {?}
+         */
+        FsUtil.prototype.isClass = /**
+         * @deprecated use import { isClass } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @param {?} cls
+         * @return {?}
+         */
+        function (value, cls) {
+            console.warn('@deprecated use import { isClass } from @firestitch/common/util; instead');
+            if (this.isObject(value)) {
+                if (this.isString(cls)) {
+                    if (value.constructor) {
+                        if (value.constructor.name === cls) {
+                            return true;
+                        }
+                    }
+                }
+                else {
+                    if (value instanceof cls) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        /**
+          * @deprecated use _.isBoolean() instead {@link https://lodash.com/docs/4.17.5#isBoolean}
+        */
+        /**
+         * @deprecated use _.isBoolean() instead {\@link https://lodash.com/docs/4.17.5#isBoolean}
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.isBoolean = /**
+         * @deprecated use _.isBoolean() instead {\@link https://lodash.com/docs/4.17.5#isBoolean}
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use _.isBoolean() instead {@link https://lodash.com/docs/4.17.5#isBoolean}');
+            return value === true || value === false;
+        };
+        /**
+         * @deprecated use import { value } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { value } from \@firestitch/common/util; instead
+         * @param {?} object
+         * @param {?} key
+         * @param {?} def
+         * @return {?}
+         */
+        FsUtil.prototype.value = /**
+         * @deprecated use import { value } from \@firestitch/common/util; instead
+         * @param {?} object
+         * @param {?} key
+         * @param {?} def
+         * @return {?}
+         */
+        function (object, key, def) {
+            console.warn('@deprecated use import { value } from @firestitch/common/util; instead');
+            if (this.isObject(object) || this.isArray(object)) {
+                if (object.hasOwnProperty(key)) {
+                    return object[key];
+                }
+            }
+            return def;
+        };
+        /**
+         * @param {?} func
+         * @param {?} wait
+         * @return {?}
+         */
+        FsUtil.prototype.throttle = /**
+         * @param {?} func
+         * @param {?} wait
+         * @return {?}
+         */
+        function (func, wait) {
+            console.warn('@deprecated use import { throttle } from @firestitch/common/util; instead');
+            /** @type {?} */
+            var waiting = false;
+            return (/**
+             * @return {?}
+             */
+            function () {
+                if (!waiting) { // If we're not waiting
+                    func.apply(null, arguments); // Execute users function
+                    waiting = true; // Prevent future invocations
+                    setTimeout((/**
+                     * @return {?}
+                     */
+                    function () {
+                        waiting = false; // And allow future invocations
+                    }), wait);
+                }
+            });
+        };
+        /**
+         * @deprecated use import { debounce } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { debounce } from \@firestitch/common/util; instead
+         * @param {?} func
+         * @param {?} wait
+         * @param {?} immediate
+         * @return {?}
+         */
+        FsUtil.prototype.debounce = /**
+         * @deprecated use import { debounce } from \@firestitch/common/util; instead
+         * @param {?} func
+         * @param {?} wait
+         * @param {?} immediate
+         * @return {?}
+         */
+        function (func, wait, immediate) {
+            console.warn('@deprecated use import { debounce } from @firestitch/common/util; instead');
+            /** @type {?} */
+            var timeout;
+            return (/**
+             * @return {?}
+             */
+            function () {
+                /** @type {?} */
+                var context = this;
+                /** @type {?} */
+                var args = arguments;
+                /** @type {?} */
+                var later = (/**
+                 * @return {?}
+                 */
+                function () {
+                    timeout = null;
+                    if (!immediate)
+                        func.apply(context, args);
+                });
+                /** @type {?} */
+                var callNow = immediate && !timeout;
+                clearTimeout(timeout);
+                timeout = setTimeout(later, wait);
+                if (callNow)
+                    func.apply(context, args);
+            });
+        };
+        /**
+         * @deprecated use import { length } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { length } from \@firestitch/common/util; instead
+         * @param {?} object
+         * @return {?}
+         */
+        FsUtil.prototype.length = /**
+         * @deprecated use import { length } from \@firestitch/common/util; instead
+         * @param {?} object
+         * @return {?}
+         */
+        function (object) {
+            console.warn('@deprecated use import { length } from @firestitch/common/util; instead');
+            if (this.isObject(object)) {
+                return Object.keys(object).length;
+            }
+            if (this.isArray(object)) {
+                return object.length;
+            }
+            return 0;
+        };
+        /**
+         * @deprecated use import { boolean } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { boolean } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.boolean = /**
+         * @deprecated use import { boolean } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use import { boolean } from @firestitch/common/util; instead');
+            return this.string(value).toLowerCase() !== 'false' && !!value;
+        };
+        /**
+         * @deprecated use import { stringify } from @firestitch/common/util; instead
+        */
+        /**
+         * @deprecated use import { stringify } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtil.prototype.stringify = /**
+         * @deprecated use import { stringify } from \@firestitch/common/util; instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            console.warn('@deprecated use import { stringify } from @firestitch/common/util; instead');
+            return JSON.stringify(value);
+        };
+        FsUtil.decorators = [
+            { type: core.Injectable }
+        ];
+        return FsUtil;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        FsUtil.prototype.intervals;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/services/vaildate.service.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsValidate = /** @class */ (function () {
+        function FsValidate(fsUtil) {
+            this.fsUtil = fsUtil;
+        }
+        /**
+         * @deprecated use import { email } from @firestitch/common/validate; instead
+        */
+        /**
+         * @deprecated use import { email } from \@firestitch/common/validate; instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsValidate.prototype.phone = /**
+         * @deprecated use import { email } from \@firestitch/common/validate; instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            /** @type {?} */
+            var valid = /^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/.test(value);
+            return valid || !String(value).length;
+        };
+        /**
+          * @deprecated use import { email } from @firestitch/common/validate; instead
+        */
+        /**
+         * @deprecated use import { email } from \@firestitch/common/validate; instead
+         * @param {?} value
+         * @return {?}
+         */
+        FsValidate.prototype.email = /**
+         * @deprecated use import { email } from \@firestitch/common/validate; instead
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return !!this.fsUtil.string(value).match(/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);
+        };
+        FsValidate.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        FsValidate.ctorParameters = function () { return [
+            { type: FsUtil }
+        ]; };
+        return FsValidate;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        FsValidate.prototype.fsUtil;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/stringify/stringify.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function stringify(value) {
+        return JSON.stringify(value);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/guid/guid.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?=} pattern
+     * @param {?=} options
+     * @return {?}
+     */
+    function guid(pattern, options) {
+        if (options === void 0) { options = { case: 'lower', numbers: true }; }
+        pattern = pattern || 'xxxxxx';
+        /** @type {?} */
+        var s = '';
+        if (options.numbers !== false) {
+            s = '0123456789';
+        }
+        if (!options.case || options.case === 'lower' || options.case === 'mixed') {
+            s = s.concat('abcdefghijklmnopqrstuvwxyz');
+        }
+        if (options.case === 'upper' || options.case === 'mixed') {
+            s = s.concat('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+        }
+        /** @type {?} */
+        var chars = s.match(/(.{1,1})/g);
+        return pattern.replace(/[x]/g, (/**
+         * @param {?} c
+         * @return {?}
+         */
+        function (c) {
+            /** @type {?} */
+            var i = (Math.random() * chars.length) | 0;
+            return chars[i];
+        }));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isEmpty/isEmpty.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @param {?=} options
+     * @return {?}
+     */
+    function isEmpty(value, options) {
+        options = options || {};
+        return value === undefined ||
+            value === null ||
+            value === false ||
+            value === '' ||
+            !lodashEs.toString(value).length ||
+            (lodashEs.isObject(value) &&
+                (value.constructor.name === 'Object' && !Object.keys(value).length)) ||
+            (!options.zero && (value === 0 || value === '0'));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/util.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsUtilStringifyPipe = /** @class */ (function () {
+        function FsUtilStringifyPipe() {
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtilStringifyPipe.prototype.transform = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return stringify(value);
+        };
+        FsUtilStringifyPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsUtilStringify'
+                    },] }
+        ];
+        /** @nocollapse */
+        FsUtilStringifyPipe.ctorParameters = function () { return []; };
+        return FsUtilStringifyPipe;
+    }());
+    var FsUtilGuidPipe = /** @class */ (function () {
+        function FsUtilGuidPipe() {
+        }
+        /**
+         * @return {?}
+         */
+        FsUtilGuidPipe.prototype.transform = /**
+         * @return {?}
+         */
+        function () {
+            return guid();
+        };
+        FsUtilGuidPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsUtilGuid'
+                    },] }
+        ];
+        /** @nocollapse */
+        FsUtilGuidPipe.ctorParameters = function () { return []; };
+        return FsUtilGuidPipe;
+    }());
+    var FsUtilIsEmptyPipe = /** @class */ (function () {
+        function FsUtilIsEmptyPipe() {
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtilIsEmptyPipe.prototype.transform = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return isEmpty(value);
+        };
+        FsUtilIsEmptyPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsUtilIsEmpty'
+                    },] }
+        ];
+        return FsUtilIsEmptyPipe;
+    }());
+    var FsUtilIsNotEmptyPipe = /** @class */ (function () {
+        function FsUtilIsNotEmptyPipe() {
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        FsUtilIsNotEmptyPipe.prototype.transform = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return !isEmpty(value);
+        };
+        FsUtilIsNotEmptyPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsUtilIsNotEmpty'
+                    },] }
+        ];
+        return FsUtilIsNotEmptyPipe;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/number/number.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @param {?=} decimals
+     * @return {?}
+     */
+    function number(value, decimals) {
+        return Number(value || 0).toLocaleString(undefined, { maximumFractionDigits: decimals });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/number.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsFormatNumberPipe = /** @class */ (function () {
+        function FsFormatNumberPipe() {
+        }
+        /**
+         * @param {?} value
+         * @param {?=} decimals
+         * @return {?}
+         */
+        FsFormatNumberPipe.prototype.transform = /**
+         * @param {?} value
+         * @param {?=} decimals
+         * @return {?}
+         */
+        function (value, decimals) {
+            return number(value, decimals);
+        };
+        FsFormatNumberPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsFormatNumber'
+                    },] }
+        ];
+        return FsFormatNumberPipe;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/currency/currency.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} amount
+     * @param {?=} precision
+     * @param {?=} currencyCode
+     * @param {?=} locale
+     * @return {?}
+     */
+    function currency(amount, precision, currencyCode, locale) {
+        if (precision === void 0) { precision = [2, 10]; }
+        if (currencyCode === void 0) { currencyCode = 'USD'; }
+        if (locale === void 0) { locale = 'en-US'; }
+        /** @type {?} */
+        var digitsInfo = lodashEs.isArray(precision) ? precision : [precision, precision];
+        return new common.CurrencyPipe(locale).transform(amount, currencyCode, 'symbol', "1." + digitsInfo[0] + "-" + digitsInfo[1]);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/currency.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsFormatCurrencyPipe = /** @class */ (function () {
+        function FsFormatCurrencyPipe(locale) {
+            this.locale = locale;
+        }
+        /**
+         * @param {?} amount
+         * @param {?=} precision
+         * @param {?=} currencyCode
+         * @return {?}
+         */
+        FsFormatCurrencyPipe.prototype.transform = /**
+         * @param {?} amount
+         * @param {?=} precision
+         * @param {?=} currencyCode
+         * @return {?}
+         */
+        function (amount, precision, currencyCode) {
+            return currency(amount, precision, currencyCode);
+        };
+        FsFormatCurrencyPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsFormatCurrency'
+                    },] }
+        ];
+        /** @nocollapse */
+        FsFormatCurrencyPipe.ctorParameters = function () { return [
+            { type: String, decorators: [{ type: core.Inject, args: [core.LOCALE_ID,] }] }
+        ]; };
+        return FsFormatCurrencyPipe;
+    }());
+    if (false) {
+        /** @type {?} */
+        FsFormatCurrencyPipe.prototype.locale;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/truncate/truncate.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @param {?=} limit
+     * @param {?=} completeWords
+     * @param {?=} ellipsis
+     * @return {?}
+     */
+    function truncate(value, limit, completeWords, ellipsis) {
+        if (limit === void 0) { limit = 100; }
+        if (completeWords === void 0) { completeWords = false; }
+        if (ellipsis === void 0) { ellipsis = '...'; }
+        value = value || '';
+        if (completeWords) {
+            limit = value.substr(0, limit).lastIndexOf(' ');
+        }
+        /** @type {?} */
+        var result = "" + value.substr(0, limit);
+        if (result !== value) {
+            result += ellipsis;
+        }
+        return result;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/truncate.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsFormatTruncatePipe = /** @class */ (function () {
+        function FsFormatTruncatePipe() {
+        }
+        /**
+         * @param {?} value
+         * @param {?=} limit
+         * @param {?=} completeWords
+         * @param {?=} ellipsis
+         * @return {?}
+         */
+        FsFormatTruncatePipe.prototype.transform = /**
+         * @param {?} value
+         * @param {?=} limit
+         * @param {?=} completeWords
+         * @param {?=} ellipsis
+         * @return {?}
+         */
+        function (value, limit, completeWords, ellipsis) {
+            return truncate(value, limit, completeWords, ellipsis);
+        };
+        FsFormatTruncatePipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsFormatTruncate'
+                    },] }
+        ];
+        /** @nocollapse */
+        FsFormatTruncatePipe.ctorParameters = function () { return []; };
+        return FsFormatTruncatePipe;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/bytes/bytes.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} bytes
+     * @return {?}
+     */
+    function bytes(bytes) {
+        if (!bytes) {
+            return '0.00 B';
+        }
+        /** @type {?} */
+        var e = Math.floor(Math.log(bytes) / Math.log(1024));
+        /** @type {?} */
+        var decimals = (bytes / 1024) > 1000 ? 2 : 0;
+        console.log(bytes, (bytes / 1024), decimals);
+        return ("" + (bytes / Math.pow(1024, e)).toFixed(decimals)).replace(/\.00/, '')
+            + ' '
+            + (e ? ' KMGTP'.charAt(e) : '') + 'B';
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/bytes.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsFormatBytesPipe = /** @class */ (function () {
+        function FsFormatBytesPipe() {
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        FsFormatBytesPipe.prototype.transform = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return bytes(value);
+        };
+        FsFormatBytesPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsFormatBytes',
+                    },] }
+        ];
+        return FsFormatBytesPipe;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/directives/stop-propagation.directive.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsStopPropagationDirective = /** @class */ (function () {
+        function FsStopPropagationDirective() {
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        FsStopPropagationDirective.prototype.preventClick = /**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
+            event.stopPropagation();
+        };
+        FsStopPropagationDirective.decorators = [
+            { type: core.Directive, args: [{
+                        selector: '[fsStopPropagation]',
+                    },] }
+        ];
+        FsStopPropagationDirective.propDecorators = {
+            preventClick: [{ type: core.HostListener, args: ['click', ['$event'],] }]
+        };
+        return FsStopPropagationDirective;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/directives/prevent-default.directive.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsPreventDefaultDirective = /** @class */ (function () {
+        function FsPreventDefaultDirective() {
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        FsPreventDefaultDirective.prototype.preventClick = /**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
+            event.preventDefault();
+        };
+        FsPreventDefaultDirective.decorators = [
+            { type: core.Directive, args: [{
+                        selector: '[fsPreventDefault]',
+                    },] }
+        ];
+        FsPreventDefaultDirective.propDecorators = {
+            preventClick: [{ type: core.HostListener, args: ['click', ['$event'],] }]
+        };
+        return FsPreventDefaultDirective;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/directives/autofocus.directive.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsAutofocusDirective = /** @class */ (function () {
+        function FsAutofocusDirective(_el) {
+            this._el = _el;
+        }
+        /**
+         * @return {?}
+         */
+        FsAutofocusDirective.prototype.ngAfterViewInit = /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            setTimeout((/**
+             * @return {?}
+             */
+            function () {
+                _this._el.nativeElement.focus();
+            }));
+        };
+        FsAutofocusDirective.decorators = [
+            { type: core.Directive, args: [{
+                        selector: '[autofocus]',
+                    },] }
+        ];
+        /** @nocollapse */
+        FsAutofocusDirective.ctorParameters = function () { return [
+            { type: core.ElementRef }
+        ]; };
+        return FsAutofocusDirective;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        FsAutofocusDirective.prototype._el;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/ordinal-number/ordinal-number.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function ordinalNumber(value) {
+        value = String(value);
+        /** @type {?} */
+        var index = value.match(templateObject_1 || (templateObject_1 = __makeTemplateObject(["1?.$"], ["1?.$"])));
+        /** @type {?} */
+        var endings = [, 'st', 'nd', 'rd'];
+        /** @type {?} */
+        var ending = endings[index] || 'th';
+        return value + ending;
+    }
+    var templateObject_1;
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/pipes/ordinal-number.pipe.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsFormatOrdinalNumberPipe = /** @class */ (function () {
+        function FsFormatOrdinalNumberPipe() {
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        FsFormatOrdinalNumberPipe.prototype.transform = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            return ordinalNumber(value);
+        };
+        FsFormatOrdinalNumberPipe.decorators = [
+            { type: core.Pipe, args: [{
+                        name: 'fsFormatOrdinalNumber',
+                    },] }
+        ];
+        return FsFormatOrdinalNumberPipe;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: app/fs-common.module.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FsCommonModule = /** @class */ (function () {
+        function FsCommonModule() {
+        }
+        /**
+         * @return {?}
+         */
+        FsCommonModule.forRoot = /**
+         * @return {?}
+         */
+        function () {
+            return {
+                ngModule: FsCommonModule,
+                providers: [
+                    FsArray,
+                    FsMath,
+                    FsUtil,
+                    FsValidate
+                ]
+            };
+        };
+        FsCommonModule.decorators = [
+            { type: core.NgModule, args: [{
+                        imports: [
+                            common.CommonModule,
+                        ],
+                        exports: [
+                            FsStopPropagationDirective,
+                            FsPreventDefaultDirective,
+                            FsAutofocusDirective,
+                            FsUtilGuidPipe,
+                            FsUtilStringifyPipe,
+                            FsFormatNumberPipe,
+                            FsFormatCurrencyPipe,
+                            FsFormatTruncatePipe,
+                            FsUtilIsEmptyPipe,
+                            FsUtilIsNotEmptyPipe,
+                            FsFormatBytesPipe,
+                            FsFormatOrdinalNumberPipe,
+                        ],
+                        declarations: [
+                            FsStopPropagationDirective,
+                            FsPreventDefaultDirective,
+                            FsAutofocusDirective,
+                            FsUtilGuidPipe,
+                            FsUtilIsEmptyPipe,
+                            FsUtilIsNotEmptyPipe,
+                            FsUtilStringifyPipe,
+                            FsFormatNumberPipe,
+                            FsFormatCurrencyPipe,
+                            FsFormatTruncatePipe,
+                            FsFormatBytesPipe,
+                            FsFormatOrdinalNumberPipe,
+                        ],
+                    },] }
+        ];
+        return FsCommonModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/email/email.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function email(value) {
+        return !!String(value).match(/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/email/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/phone/phone.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function phone(value) {
+        /** @type {?} */
+        var valid = /^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4}/.test(value);
+        return valid || !String(value).length;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/phone/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/url/url.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * Check validity of the url.
+     * Protocol (http/https) isn't required.
+     * @param value
+     * @returns {boolean}
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function url(value) {
+        /** @type {?} */
+        var expression = /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/gm;
+        /** @type {?} */
+        var regexp = new RegExp(expression);
+        return !!String(value).match(regexp);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/url/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/validate/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/compare/compare.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} query
+     * @param {?} item
+     * @return {?}
+     */
+    function compare(query, item) {
+        /** @type {?} */
+        var value = true;
+        for (var key in query) {
+            value = value && item[key] == query[key];
+        }
+        return value;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/compare/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/filter/filter.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    function filter(array, query) {
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            var queryObj_1 = query;
+            query = (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                return compare(queryObj_1, item);
+            });
+        }
+        /** @type {?} */
+        var isarray = Array.isArray(array);
+        /** @type {?} */
+        var list = isarray ? [] : {};
+        if (isarray) {
+            array.forEach((/**
+             * @param {?} item
+             * @param {?} idx
+             * @return {?}
+             */
+            function (item, idx) {
+                if (query(item)) {
+                    list.push(item);
+                }
+            }));
+        }
+        else {
+            Object.keys(array).forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            function (key) {
+                if (query(array[key])) {
+                    list[key] = array[key];
+                }
+            }));
+        }
+        return list;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/filter/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/inArray/inArray.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} values
+     * @param {?} array
+     * @return {?}
+     */
+    function inArray(values, array) {
+        if (!Array.isArray(values)) {
+            values = [values];
+        }
+        for (var i = 0, len = values.length; i < len; i++) {
+            if (array.indexOf(values[i]) >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/inArray/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/index/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} property
+     * @return {?}
+     */
+    function index(array, property) {
+        /** @type {?} */
+        var list = {};
+        array.forEach((/**
+         * @param {?} item
+         * @param {?} idx
+         * @return {?}
+         */
+        function (item, idx) {
+            list[item[property]] = item;
+        }));
+        return list;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/indexOf/indexOf.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    function indexOf(array, query) {
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            var queryObj_1 = query;
+            query = (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                return compare(queryObj_1, item);
+            });
+        }
+        for (var i = 0, len = array.length; i < len; i++) {
+            if (query(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/indexOf/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/keyExists/keyExists.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} key
+     * @return {?}
+     */
+    function keyExists(array, key) {
+        return array.hasOwnProperty(key);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/keyExists/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/ksort/ksort.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} unordered
+     * @return {?}
+     */
+    function ksort(unordered) {
+        Object.keys(unordered).sort().forEach((/**
+         * @param {?} key
+         * @return {?}
+         */
+        function (key) {
+            /** @type {?} */
+            var value = unordered[key];
+            delete unordered[key];
+            unordered[key] = value;
+        }));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/ksort/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/list/list.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} property
+     * @param {?=} index
+     * @return {?}
+     */
+    function list(array, property, index) {
+        if (index === void 0) { index = null; }
+        /** @type {?} */
+        var resultList = index ? {} : [];
+        array.forEach((/**
+         * @param {?} item
+         * @param {?} idx
+         * @return {?}
+         */
+        function (item, idx) {
+            if (index) {
+                resultList[item[index]] = item[property];
+            }
+            else {
+                resultList.push(item[property]);
+            }
+        }));
+        return resultList;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/list/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/nameValue/nameValue.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    function nameValue(array, name, value) {
+        /** @type {?} */
+        var list = [];
+        if (name || value) {
+            /** @type {?} */
+            var nameFn_1 = typeof name === 'function' ? name : (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                return item[name];
+            });
+            /** @type {?} */
+            var valueFn_1 = typeof value === 'function' ? value : (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                return item[value];
+            });
+            array.forEach((/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                list.push({ name: nameFn_1(item), value: valueFn_1(item) });
+            }));
+        }
+        else {
+            array.forEach((/**
+             * @param {?} n
+             * @param {?} v
+             * @return {?}
+             */
+            function (n, v) {
+                list.push({ name: n, value: v });
+            }));
+        }
+        return list;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/nameValue/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/remove/remove.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    function remove(array, query) {
+        /** @type {?} */
+        var idx = indexOf(array, query);
+        if (idx >= 0) {
+            return array.splice(idx, 1);
+        }
+        return idx;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/remove/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/sort/sort.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @param {?=} reverse
+     * @return {?}
+     */
+    function sort(array, query, reverse) {
+        if (reverse === void 0) { reverse = false; }
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            var queryStr_1 = query;
+            query = (/**
+             * @param {?} a
+             * @param {?} b
+             * @return {?}
+             */
+            function (a, b) {
+                if (reverse) {
+                    if (a[queryStr_1] < b[queryStr_1]) {
+                        return 1;
+                    }
+                    else if (a[queryStr_1] > b[queryStr_1]) {
+                        return -1;
+                    }
+                }
+                else {
+                    if (a[queryStr_1] > b[queryStr_1]) {
+                        return 1;
+                    }
+                    else if (a[queryStr_1] < b[queryStr_1]) {
+                        return -1;
+                    }
+                }
+                return 0;
+            });
+        }
+        array.sort(query);
+        return array;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/sort/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/rsort/rsort.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    function rsort(array, query) {
+        return sort(array, query, true);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/rsort/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/find/find.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    function find(array, query) {
+        /** @type {?} */
+        var data = filter(array, query);
+        return data.length ? data[0] : null;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/find/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/array/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/boolean/boolean.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function boolean(value) {
+        return lodashEs.toString(value).toLowerCase() !== 'false' && !!value;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/boolean/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/debounce/debounce.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} func
+     * @param {?} wait
+     * @param {?} immediate
+     * @return {?}
+     */
+    function debounce(func, wait, immediate) {
+        /** @type {?} */
+        var timeout;
+        return (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var context = this;
+            /** @type {?} */
+            var args = arguments;
+            /** @type {?} */
+            var later = (/**
+             * @return {?}
+             */
+            function () {
+                timeout = null;
+                if (!immediate)
+                    func.apply(context, args);
+            });
+            /** @type {?} */
+            var callNow = immediate && !timeout;
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+            if (callNow)
+                func.apply(context, args);
+        });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/debounce/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/guid/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/keys/keys.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var KEY_CANCEL$1 = 3;
+    /** @type {?} */
+    var KEY_HELP$1 = 6;
+    /** @type {?} */
+    var KEY_BACKSPACE$1 = 8;
+    /** @type {?} */
+    var KEY_TAB$1 = 9;
+    /** @type {?} */
+    var KEY_CLEAR$1 = 12;
+    /** @type {?} */
+    var KEY_RETURN$1 = 13;
+    /** @type {?} */
+    var KEY_ENTER$1 = 14;
+    /** @type {?} */
+    var KEY_SHIFT$1 = 16;
+    /** @type {?} */
+    var KEY_CONTROL$1 = 17;
+    /** @type {?} */
+    var KEY_ALT$1 = 18;
+    /** @type {?} */
+    var KEY_PAUSE$1 = 19;
+    /** @type {?} */
+    var KEY_CAPS_LOCK$1 = 20;
+    /** @type {?} */
+    var KEY_ESCAPE$1 = 27;
+    /** @type {?} */
+    var KEY_SPACE$1 = 32;
+    /** @type {?} */
+    var KEY_PAGE_UP$1 = 33;
+    /** @type {?} */
+    var KEY_PAGE_DOWN$1 = 34;
+    /** @type {?} */
+    var KEY_END$1 = 35;
+    /** @type {?} */
+    var KEY_HOME$1 = 36;
+    /** @type {?} */
+    var KEY_LEFT$1 = 37;
+    /** @type {?} */
+    var KEY_UP$1 = 38;
+    /** @type {?} */
+    var KEY_RIGHT$1 = 39;
+    /** @type {?} */
+    var KEY_DOWN$1 = 40;
+    /** @type {?} */
+    var KEY_PRINTSCREEN$1 = 44;
+    /** @type {?} */
+    var KEY_INSERT$1 = 45;
+    /** @type {?} */
+    var KEY_DELETE$1 = 46;
+    /** @type {?} */
+    var KEY_0$1 = 48;
+    /** @type {?} */
+    var KEY_1$1 = 49;
+    /** @type {?} */
+    var KEY_2$1 = 50;
+    /** @type {?} */
+    var KEY_3$1 = 51;
+    /** @type {?} */
+    var KEY_4$1 = 52;
+    /** @type {?} */
+    var KEY_5$1 = 53;
+    /** @type {?} */
+    var KEY_6$1 = 54;
+    /** @type {?} */
+    var KEY_7$1 = 55;
+    /** @type {?} */
+    var KEY_8$1 = 56;
+    /** @type {?} */
+    var KEY_9$1 = 57;
+    /** @type {?} */
+    var KEY_SEMICOLON$1 = 59;
+    /** @type {?} */
+    var KEY_EQUALS$1 = 61;
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/keys/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/length/length.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} object
+     * @return {?}
+     */
+    function length(object) {
+        if (lodashEs.isObject(object)) {
+            return Object.keys(object).length;
+        }
+        if (lodashEs.isArray(object)) {
+            return object.length;
+        }
+        return 0;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/length/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/resolve/resolve.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} promise
+     * @param {?=} defaults
+     * @return {?}
+     */
+    function resolve(promise, defaults) {
+        if (defaults === void 0) { defaults = []; }
+        /** @type {?} */
+        var result = defaults;
+        return new Promise((/**
+         * @param {?} resolve
+         * @return {?}
+         */
+        function (resolve) {
+            promise.then((/**
+             * @param {?} data
+             * @return {?}
+             */
+            function (data) {
+                Object.keys(data).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                function (key) { return result[key] = data[key]; }));
+                resolve(result);
+            }));
+        }));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/resolve/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/stringify/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/uuid/uuid.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @return {?}
+     */
+    function uuid() {
+        return guid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/uuid/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/value/value.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} object
+     * @param {?} key
+     * @param {?} def
+     * @return {?}
+     */
+    function value(object, key, def) {
+        if (typeof object === 'object' || Array.isArray(object)) {
+            if (object.hasOwnProperty(key)) {
+                return object[key];
+            }
+        }
+        return def;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/value/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isClass/isClass.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @param {?} cls
+     * @return {?}
+     */
+    function isClass(value, cls) {
+        if (typeof value === 'object') {
+            if (typeof cls === 'string') {
+                if (value.constructor) {
+                    if (value.constructor.name === cls) {
+                        return true;
+                    }
+                }
+            }
+            else {
+                if (value instanceof cls) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isClass/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isNumeric/isNumeric.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function isNumeric(value) {
+        /** @type {?} */
+        var str = lodashEs.toString(value);
+        return str.length && !!str.match(/^-?\d*\.?\d*$/);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isNumeric/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/isEmpty/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/throttle/throttle.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} func
+     * @param {?} wait
+     * @return {?}
+     */
+    function throttle(func, wait) {
+        /** @type {?} */
+        var waiting = false;
+        return (/**
+         * @return {?}
+         */
+        function () {
+            if (!waiting) { // If we're not waiting
+                func.apply(null, arguments); // Execute users function
+                waiting = true; // Prevent future invocations
+                setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    waiting = false; // And allow future invocations
+                }), wait);
+            }
+        });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/throttle/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/queue/operation.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var Operation = /** @class */ (function () {
+        function Operation(target, name) {
+            this.ready$ = new rxjs.Subject();
+            this.name = name ? name : guid();
+            if (target instanceof rxjs.Observable) {
+                this.target = target;
+            }
+            else {
+                this.target = rxjs.of(target);
+            }
+        }
+        return Operation;
+    }());
+    if (false) {
+        /** @type {?} */
+        Operation.prototype.name;
+        /** @type {?} */
+        Operation.prototype.target;
+        /** @type {?} */
+        Operation.prototype.ready$;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/queue/queue.enum.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @enum {string} */
+    var QueueState = {
+        Idle: "idle",
+        Processing: "processing",
+    };
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/queue/queue.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var Queue = /** @class */ (function () {
+        function Queue(_limit) {
+            if (_limit === void 0) { _limit = Infinity; }
+            this._limit = _limit;
+            this._done = new rxjs.Subject();
+            this._queue = [];
+            this._inProgress = [];
+            this._total = 0;
+            this._completed = 0;
+            this._errors = 0;
+            this._state = QueueState.Idle;
+            this._destroy$ = new rxjs.Subject();
+        }
+        Object.defineProperty(Queue.prototype, "total", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._total;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "completed", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._completed;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "pending", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._queue.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "inProgress", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._inProgress.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "errors", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._errors;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "state", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._state;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "empty", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return !this._queue.length && !this._inProgress.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "pendingOperations", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._queue
+                    .map((/**
+                 * @param {?} operation
+                 * @return {?}
+                 */
+                function (operation) { return operation.name; }));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "inProgressOperations", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._inProgress
+                    .map((/**
+                 * @param {?} operation
+                 * @return {?}
+                 */
+                function (operation) { return operation.name; }));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @return {?}
+         */
+        Queue.prototype.isProcessing = /**
+         * @return {?}
+         */
+        function () {
+            return this._state === QueueState.Processing;
+        };
+        /**
+         * @return {?}
+         */
+        Queue.prototype.isIdle = /**
+         * @return {?}
+         */
+        function () {
+            return this._state === QueueState.Idle;
+        };
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        Queue.prototype.setLimit = /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._limit = value;
+        };
+        /**
+         * @param {?} fun
+         * @param {?=} err
+         * @param {?=} complete
+         * @return {?}
+         */
+        Queue.prototype.subscribe = /**
+         * @param {?} fun
+         * @param {?=} err
+         * @param {?=} complete
+         * @return {?}
+         */
+        function (fun, err, complete) {
+            this._done
+                .pipe(operators.takeUntil(this._destroy$))
+                .subscribe(fun, err, complete);
+        };
+        /**
+         * @param {?} fun
+         * @param {?=} err
+         * @param {?=} complete
+         * @return {?}
+         */
+        Queue.prototype.complete = /**
+         * @param {?} fun
+         * @param {?=} err
+         * @param {?=} complete
+         * @return {?}
+         */
+        function (fun, err, complete) {
+            var _this = this;
+            rxjs.Observable.create((/**
+             * @param {?} observer
+             * @return {?}
+             */
+            function (observer) {
+                if (!_this.isProcessing()) {
+                    observer.next();
+                    observer.complete();
+                    return;
+                }
+                _this.subscribe((/**
+                 * @return {?}
+                 */
+                function () {
+                    observer.next();
+                    observer.complete();
+                }), (/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    observer.error(error);
+                    _this.clear();
+                }));
+            })).subscribe(fun, err, complete);
+        };
+        /**
+         * @param {?} target
+         * @param {?=} name
+         * @return {?}
+         */
+        Queue.prototype.push = /**
+         * @param {?} target
+         * @param {?=} name
+         * @return {?}
+         */
+        function (target, name) {
+            /** @type {?} */
+            var operation = new Operation(target, name);
+            this._total++;
+            this._state = QueueState.Processing;
+            if (this._inProgress.length < this._limit) {
+                this._processOperation(operation);
+            }
+            else {
+                this._queue.push(operation);
+            }
+            return operation.ready$;
+        };
+        /**
+         * @return {?}
+         */
+        Queue.prototype.clear = /**
+         * @return {?}
+         */
+        function () {
+            this._queue = [];
+            this._total = 0;
+            this._errors = 0;
+            this._completed = 0;
+            this._state = QueueState.Idle;
+            this._done = new rxjs.Subject();
+        };
+        /**
+         * @return {?}
+         */
+        Queue.prototype.destroy = /**
+         * @return {?}
+         */
+        function () {
+            this.clear();
+            this._done.complete();
+        };
+        /**
+         * @private
+         * @param {?} operation
+         * @return {?}
+         */
+        Queue.prototype._processOperation = /**
+         * @private
+         * @param {?} operation
+         * @return {?}
+         */
+        function (operation) {
+            var _this = this;
+            this._inProgress.push(operation);
+            operation.target
+                .pipe(operators.delay(200), // Hack to prevent extra quick proccess execution
+            operators.takeUntil(this._destroy$)).subscribe({
+                next: (/**
+                 * @param {?} data
+                 * @return {?}
+                 */
+                function (data) {
+                    operation.ready$.next(data);
+                }),
+                error: (/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    /** @type {?} */
+                    var opIndex = _this._inProgress.indexOf(operation);
+                    _this._inProgress.splice(opIndex, 1);
+                    _this._errors++;
+                    operation.ready$.error(error);
+                    if (_this.empty) {
+                        _this._state = QueueState.Idle;
+                        _this._done.error(error);
+                    }
+                }),
+                complete: (/**
+                 * @return {?}
+                 */
+                function () {
+                    /** @type {?} */
+                    var opIndex = _this._inProgress.indexOf(operation);
+                    _this._inProgress.splice(opIndex, 1);
+                    _this._completed++;
+                    operation.ready$.complete();
+                    if (_this.empty) {
+                        _this._state = QueueState.Idle;
+                        _this._done.next();
+                    }
+                    else {
+                        if (_this._queue.length) {
+                            /** @type {?} */
+                            var queueItem = _this._queue.shift();
+                            _this._processOperation(queueItem);
+                        }
+                    }
+                })
+            });
+        };
+        return Queue;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._done;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._queue;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._inProgress;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._total;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._completed;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._errors;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._state;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._destroy$;
+        /**
+         * @type {?}
+         * @private
+         */
+        Queue.prototype._limit;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/queue/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/remove-query-params/remove-query-params.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} path
+     * @return {?}
+     */
+    function removeQueryParams(path) {
+        return path.split('?')[0];
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/remove-query-params/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/get-normalized-path/get-normalized-path.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} locationSrv
+     * @return {?}
+     */
+    function getNormalizedPath(locationSrv) {
+        /** @type {?} */
+        var path = locationSrv.prepareExternalUrl(locationSrv.path());
+        return removeQueryParams(path);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/get-normalized-path/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/util/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/number/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/acronym/acronym.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} str
+     * @param {?=} length
+     * @return {?}
+     */
+    function acronym(str, length) {
+        if (length === void 0) { length = 2; }
+        /** @type {?} */
+        var splittedString = str
+            .replace(/[^a-zA-Z0-9]+/g, ' ')
+            .split(' ');
+        /** @type {?} */
+        var result = '';
+        for (var i = 0; i < length; i++) {
+            if (!splittedString[i]) {
+                if (splittedString.length === 1) {
+                    for (var j = 1; j < length; j++) {
+                        if (!splittedString[i - 1][j]) {
+                            break;
+                        }
+                        result += splittedString[i - 1][j].toUpperCase();
+                    }
+                }
+                break;
+            }
+            result += splittedString[i][0].toUpperCase();
+        }
+        return result;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/acronym/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/currency/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/truncate/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/bytes/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/format/index.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * Generated from: libs/rxjs/delayedRetry.ts
+     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} delayMs
+     * @param {?=} maxRetry
+     * @param {?=} message
+     * @return {?}
+     */
+    function delayedRetry(delayMs, maxRetry, message) {
+        if (maxRetry === void 0) { maxRetry = 5; }
+        /** @type {?} */
+        var retries = 0;
+        return (/**
+         * @param {?} src
+         * @return {?}
+         */
+        function (src) {
+            return src.pipe(operators.retryWhen((/**
+             * @param {?} errors
+             * @return {?}
+             */
+            function (errors) {
+                return errors.pipe(operators.tap((/**
+                 * @return {?}
+                 */
+                function () {
+                    retries++;
+                    if (retries <= maxRetry) {
+                        console.info("Failed to load Resource. Retry in " + delayMs / 1000 + " sec. " + retries + "/" + maxRetry + " times...");
+                    }
+                })), operators.concatMap((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    return rxjs.iif((/**
+                     * @return {?}
+                     */
+                    function () { return retries > maxRetry; }), rxjs.throwError(getErrorMessage(maxRetry, message)), rxjs.timer(delayMs));
+                })));
+            })));
+        });
+    }
+    /** @type {?} */
+    var getErrorMessage = (/**
+     * @param {?} maxRetry
+     * @param {?} defaultMessage
+     * @return {?}
+     */
+    function (maxRetry, defaultMessage) {
+        if (!defaultMessage) {
+            return "Failed to load Resource for " + maxRetry + " times. Giving up.";
+        }
+        else {
+            return defaultMessage;
+        }
+    });
+    var ɵ0 = getErrorMessage;
+
+    exports.FsArray = FsArray;
+    exports.FsCommonModule = FsCommonModule;
+    exports.FsMath = FsMath;
+    exports.FsUtil = FsUtil;
+    exports.FsValidate = FsValidate;
+    exports.KEY_0 = KEY_0$1;
+    exports.KEY_1 = KEY_1$1;
+    exports.KEY_2 = KEY_2$1;
+    exports.KEY_3 = KEY_3$1;
+    exports.KEY_4 = KEY_4$1;
+    exports.KEY_5 = KEY_5$1;
+    exports.KEY_6 = KEY_6$1;
+    exports.KEY_7 = KEY_7$1;
+    exports.KEY_8 = KEY_8$1;
+    exports.KEY_9 = KEY_9$1;
+    exports.KEY_ALT = KEY_ALT$1;
+    exports.KEY_BACKSPACE = KEY_BACKSPACE$1;
+    exports.KEY_CANCEL = KEY_CANCEL$1;
+    exports.KEY_CAPS_LOCK = KEY_CAPS_LOCK$1;
+    exports.KEY_CLEAR = KEY_CLEAR$1;
+    exports.KEY_CONTROL = KEY_CONTROL$1;
+    exports.KEY_DELETE = KEY_DELETE$1;
+    exports.KEY_DOWN = KEY_DOWN$1;
+    exports.KEY_END = KEY_END$1;
+    exports.KEY_ENTER = KEY_ENTER$1;
+    exports.KEY_EQUALS = KEY_EQUALS$1;
+    exports.KEY_ESCAPE = KEY_ESCAPE$1;
+    exports.KEY_HELP = KEY_HELP$1;
+    exports.KEY_HOME = KEY_HOME$1;
+    exports.KEY_INSERT = KEY_INSERT$1;
+    exports.KEY_LEFT = KEY_LEFT$1;
+    exports.KEY_PAGE_DOWN = KEY_PAGE_DOWN$1;
+    exports.KEY_PAGE_UP = KEY_PAGE_UP$1;
+    exports.KEY_PAUSE = KEY_PAUSE$1;
+    exports.KEY_PRINTSCREEN = KEY_PRINTSCREEN$1;
+    exports.KEY_RETURN = KEY_RETURN$1;
+    exports.KEY_RIGHT = KEY_RIGHT$1;
+    exports.KEY_SEMICOLON = KEY_SEMICOLON$1;
+    exports.KEY_SHIFT = KEY_SHIFT$1;
+    exports.KEY_SPACE = KEY_SPACE$1;
+    exports.KEY_TAB = KEY_TAB$1;
+    exports.KEY_UP = KEY_UP$1;
+    exports.Queue = Queue;
+    exports.QueueState = QueueState;
+    exports.acronym = acronym;
+    exports.boolean = boolean;
+    exports.bytes = bytes;
+    exports.compare = compare;
+    exports.currency = currency;
+    exports.debounce = debounce;
+    exports.delayedRetry = delayedRetry;
+    exports.email = email;
+    exports.filter = filter;
+    exports.find = find;
+    exports.getNormalizedPath = getNormalizedPath;
+    exports.guid = guid;
+    exports.inArray = inArray;
+    exports.index = index;
+    exports.indexOf = indexOf;
+    exports.isClass = isClass;
+    exports.isEmpty = isEmpty;
+    exports.isNumeric = isNumeric;
+    exports.keyExists = keyExists;
+    exports.ksort = ksort;
+    exports.length = length;
+    exports.list = list;
+    exports.nameValue = nameValue;
+    exports.number = number;
+    exports.ordinalNumber = ordinalNumber;
+    exports.phone = phone;
+    exports.remove = remove;
+    exports.removeQueryParams = removeQueryParams;
+    exports.resolve = resolve;
+    exports.rsort = rsort;
+    exports.sort = sort;
+    exports.stringify = stringify;
+    exports.throttle = throttle;
+    exports.truncate = truncate;
+    exports.url = url;
+    exports.uuid = uuid;
+    exports.value = value;
+    exports.ɵa = FsStopPropagationDirective;
+    exports.ɵb = FsPreventDefaultDirective;
+    exports.ɵc = FsAutofocusDirective;
+    exports.ɵd = FsUtilStringifyPipe;
+    exports.ɵe = FsUtilGuidPipe;
+    exports.ɵf = FsUtilIsEmptyPipe;
+    exports.ɵg = FsUtilIsNotEmptyPipe;
+    exports.ɵh = FsFormatNumberPipe;
+    exports.ɵi = FsFormatCurrencyPipe;
+    exports.ɵj = FsFormatTruncatePipe;
+    exports.ɵk = FsFormatBytesPipe;
+    exports.ɵl = FsFormatOrdinalNumberPipe;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=firestitch-common.umd.js.map