@firestitch/common 8.0.10

package/fesm2015/firestitch-common.js

@@ -0,0 +1,2769 @@
+import { Injectable, Pipe, Inject, LOCALE_ID, Directive, HostListener, ElementRef, NgModule } from '@angular/core';
+import { CurrencyPipe, CommonModule } from '@angular/common';
+import { toString, isObject, isArray } from 'lodash-es';
+import { Subject, Observable, of, iif, throwError, timer } from 'rxjs';
+import { takeUntil, delay, retryWhen, tap, concatMap } from 'rxjs/operators';
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/services/array.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsArray {
+    /**
+     * @deprecated use import { nameValue } from \@firestitch/common/array; instead
+     * @param {?} array
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    nameValue(array, name, value) {
+        console.warn('@deprecated use import { nameValue } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let list = [];
+        if (name || value) {
+            /** @type {?} */
+            let nameFn = typeof name === 'function' ? name : (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) { return item[name]; });
+            /** @type {?} */
+            let valueFn = typeof value === 'function' ? value : (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) { return item[value]; });
+            array.forEach((/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) {
+                list.push({ name: nameFn(item), value: valueFn(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
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    remove(array, query) {
+        console.warn('@deprecated use import { remove } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let idx = this.indexOf(array, query);
+        if (idx >= 0) {
+            return array.splice(idx, 1);
+        }
+        return idx;
+    }
+    /**
+     * @deprecated use import { indexOf } from \@firestitch/common/array; instead
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    indexOf(array, query) {
+        console.warn('@deprecated use import { indexOf } from @firestitch/common/array; instead');
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            let queryObj = query;
+            query = (/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                return this.compare(queryObj, item);
+            });
+        }
+        for (let 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
+     * @param {?} query
+     * @param {?} item
+     * @return {?}
+     */
+    compare(query, item) {
+        console.warn('@deprecated use import { compare } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let value = true;
+        for (let key in query) {
+            value = value && item[key] == query[key];
+        }
+        return value;
+    }
+    /**
+     * @deprecated use import { filter } from \@firestitch/common/array; instead
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    filter(array, query) {
+        console.warn('@deprecated use import { filter } from @firestitch/common/array; instead');
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            let queryObj = query;
+            query = (/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                return this.compare(queryObj, item);
+            });
+        }
+        /** @type {?} */
+        let isarray = Array.isArray(array);
+        /** @type {?} */
+        let 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 {?}
+             */
+            key => {
+                if (query(array[key])) {
+                    list[key] = array[key];
+                }
+            }));
+        return list;
+    }
+    /**
+     * @deprecated use import { index } from \@firestitch/common/array; instead
+     * @param {?} array
+     * @param {?} property
+     * @return {?}
+     */
+    index(array, property) {
+        console.warn('@deprecated use import { index } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let 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
+     * @param {?} array
+     * @param {?} query
+     * @param {?=} reverse
+     * @return {?}
+     */
+    sort(array, query, reverse = false) {
+        console.warn('@deprecated use import { sort } from @firestitch/common/array; instead');
+        if (typeof query !== 'function') {
+            /** @type {?} */
+            let queryStr = query;
+            query = (/**
+             * @param {?} a
+             * @param {?} b
+             * @return {?}
+             */
+            function (a, b) {
+                if (reverse) {
+                    if (a[queryStr] < b[queryStr]) {
+                        return 1;
+                    }
+                    else if (a[queryStr] > b[queryStr]) {
+                        return -1;
+                    }
+                }
+                else {
+                    if (a[queryStr] > b[queryStr]) {
+                        return 1;
+                    }
+                    else if (a[queryStr] < b[queryStr]) {
+                        return -1;
+                    }
+                }
+                return 0;
+            });
+        }
+        array.sort(query);
+        return array;
+    }
+    /**
+     * @deprecated use import { rsort } from \@firestitch/common/array; instead
+     * @param {?} array
+     * @param {?} query
+     * @return {?}
+     */
+    rsort(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
+     * @param {?} array
+     * @param {?} property
+     * @param {?=} index
+     * @return {?}
+     */
+    list(array, property, index = null) {
+        console.warn('@deprecated use import { list } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let 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
+     * @param {?} objects
+     * @param {?} parent_property
+     * @param {?=} id_property
+     * @param {?=} depth_property
+     * @return {?}
+     */
+    applyDepth(objects, parent_property, id_property = 'id', depth_property = 'depth') {
+        console.warn('@deprecated use import { applyDepth } from @firestitch/common/array; instead');
+        /** @type {?} */
+        let 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 {?}
+         */
+        key => {
+            Object.keys(keyed).forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            key => {
+                /** @type {?} */
+                let 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
+     * @param {?} values
+     * @param {?} array
+     * @return {?}
+     */
+    inArray(values, array) {
+        console.warn('@deprecated use import { inArray } from @firestitch/common/array; instead');
+        if (!Array.isArray(values)) {
+            values = [values];
+        }
+        for (let 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
+     * @param {?} array
+     * @param {?} key
+     * @return {?}
+     */
+    keyExists(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
+     * @param {?} array
+     * @return {?}
+     */
+    length(array) {
+        console.warn('@deprecated use import { length } from @firestitch/common/array; instead');
+        return array.length;
+    }
+    /**
+     * @deprecated use import { ksort } from \@firestitch/common/array; instead
+     * @param {?} unordered
+     * @return {?}
+     */
+    ksort(unordered) {
+        console.warn('@deprecated use import { ksort } from @firestitch/common/array; instead');
+        Object.keys(unordered).sort().forEach((/**
+         * @param {?} key
+         * @return {?}
+         */
+        function (key) {
+            /** @type {?} */
+            let value = unordered[key];
+            delete unordered[key];
+            unordered[key] = value;
+        }));
+    }
+}
+FsArray.decorators = [
+    { type: Injectable }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/services/math.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsMath {
+    /**
+     * @deprecated use _.round() instead {\@link https://lodash.com/docs/4.17.5#round}
+     * @param {?} number
+     * @param {?} precision
+     * @return {?}
+     */
+    round(number, precision) {
+        console.warn('@deprecated use _.round() instead {@link https://lodash.com/docs/4.17.5#round}');
+        precision = precision || 0;
+        /** @type {?} */
+        let factor = Math.pow(10, precision);
+        /** @type {?} */
+        let tempNumber = number * factor;
+        /** @type {?} */
+        let roundedTempNumber = Math.round(tempNumber);
+        return roundedTempNumber / factor;
+    }
+}
+FsMath.decorators = [
+    { type: Injectable }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/services/util.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const KEY_CANCEL = 3;
+/** @type {?} */
+const KEY_HELP = 6;
+/** @type {?} */
+const KEY_BACKSPACE = 8;
+/** @type {?} */
+const KEY_TAB = 9;
+/** @type {?} */
+const KEY_CLEAR = 12;
+/** @type {?} */
+const KEY_RETURN = 13;
+/** @type {?} */
+const KEY_ENTER = 14;
+/** @type {?} */
+const KEY_SHIFT = 16;
+/** @type {?} */
+const KEY_CONTROL = 17;
+/** @type {?} */
+const KEY_ALT = 18;
+/** @type {?} */
+const KEY_PAUSE = 19;
+/** @type {?} */
+const KEY_CAPS_LOCK = 20;
+/** @type {?} */
+const KEY_ESCAPE = 27;
+/** @type {?} */
+const KEY_SPACE = 32;
+/** @type {?} */
+const KEY_PAGE_UP = 33;
+/** @type {?} */
+const KEY_PAGE_DOWN = 34;
+/** @type {?} */
+const KEY_END = 35;
+/** @type {?} */
+const KEY_HOME = 36;
+/** @type {?} */
+const KEY_LEFT = 37;
+/** @type {?} */
+const KEY_UP = 38;
+/** @type {?} */
+const KEY_RIGHT = 39;
+/** @type {?} */
+const KEY_DOWN = 40;
+/** @type {?} */
+const KEY_PRINTSCREEN = 44;
+/** @type {?} */
+const KEY_INSERT = 45;
+/** @type {?} */
+const KEY_DELETE = 46;
+/** @type {?} */
+const KEY_0 = 48;
+/** @type {?} */
+const KEY_1 = 49;
+/** @type {?} */
+const KEY_2 = 50;
+/** @type {?} */
+const KEY_3 = 51;
+/** @type {?} */
+const KEY_4 = 52;
+/** @type {?} */
+const KEY_5 = 53;
+/** @type {?} */
+const KEY_6 = 54;
+/** @type {?} */
+const KEY_7 = 55;
+/** @type {?} */
+const KEY_8 = 56;
+/** @type {?} */
+const KEY_9 = 57;
+/** @type {?} */
+const KEY_SEMICOLON = 59;
+/** @type {?} */
+const 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
+*/
+class FsUtil {
+    constructor() {
+        this.intervals = {};
+    }
+    /**
+     * @deprecated use \@firestitch/common/util/guid instead
+     * @param {?=} pattern
+     * @return {?}
+     */
+    guid(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
+     * @return {?}
+     */
+    uuid() {
+        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
+     * @param {?} promise
+     * @param {?=} defaults
+     * @return {?}
+     */
+    resolve(promise, defaults = []) {
+        console.warn('@deprecated use @firestitch/common/util/resolve instead');
+        /** @type {?} */
+        const result = defaults;
+        return new Promise((/**
+         * @param {?} resolve
+         * @return {?}
+         */
+        resolve => {
+            promise.then((/**
+             * @param {?} data
+             * @return {?}
+             */
+            function (data) {
+                Object.keys(data).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                key => result[key] = data[key]));
+                resolve(result);
+            }));
+        }));
+    }
+    /**
+     * @deprecated use _.toInteger() instead
+     * @param {?} value
+     * @return {?}
+     */
+    int(value) {
+        console.warn('@deprecated use _.toInteger() instead');
+        value = parseInt(value);
+        if (isNaN(value)) {
+            value = 0;
+        }
+        return value;
+    }
+    /**
+     * @deprecated use _.toFinite() instead
+     * @param {?} value
+     * @return {?}
+     */
+    float(value) {
+        console.warn('@deprecated use _.toFinite() instead');
+        value = parseFloat(value);
+        if (isNaN(value)) {
+            value = 0;
+        }
+        return value;
+    }
+    /**
+     * @deprecated use _.toString() instead
+     * @param {?} string
+     * @return {?}
+     */
+    string(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
+     * @param {?} value
+     * @param {?=} options
+     * @return {?}
+     */
+    isEmpty(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
+     * @param {?} value
+     * @param {?=} type
+     * @return {?}
+     */
+    isInt(value, type) {
+        console.warn('@deprecated use _.isInteger() instead');
+        /** @type {?} */
+        const 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}
+     * @param {?} object
+     * @param {?} func
+     * @return {?}
+     */
+    each(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
+     * @param {?} value
+     * @return {?}
+     */
+    isObject(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}
+     * @param {?} value
+     * @return {?}
+     */
+    isString(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}
+     * @param {?} value
+     * @return {?}
+     */
+    isArray(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
+     * @param {?} value
+     * @return {?}
+     */
+    isNumeric(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
+     * @param {?} value
+     * @param {?} cls
+     * @return {?}
+     */
+    isClass(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}
+     * @param {?} value
+     * @return {?}
+     */
+    isBoolean(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
+     * @param {?} object
+     * @param {?} key
+     * @param {?} def
+     * @return {?}
+     */
+    value(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 {?}
+     */
+    throttle(func, wait) {
+        console.warn('@deprecated use import { throttle } from @firestitch/common/util; instead');
+        /** @type {?} */
+        let 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
+     * @param {?} func
+     * @param {?} wait
+     * @param {?} immediate
+     * @return {?}
+     */
+    debounce(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
+     * @param {?} object
+     * @return {?}
+     */
+    length(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
+     * @param {?} value
+     * @return {?}
+     */
+    boolean(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
+     * @param {?} value
+     * @return {?}
+     */
+    stringify(value) {
+        console.warn('@deprecated use import { stringify } from @firestitch/common/util; instead');
+        return JSON.stringify(value);
+    }
+}
+FsUtil.decorators = [
+    { type: Injectable }
+];
+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
+ */
+class FsValidate {
+    /**
+     * @param {?} fsUtil
+     */
+    constructor(fsUtil) {
+        this.fsUtil = fsUtil;
+    }
+    /**
+     * @deprecated use import { email } from \@firestitch/common/validate; instead
+     * @param {?} value
+     * @return {?}
+     */
+    phone(value) {
+        /** @type {?} */
+        const 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
+     * @param {?} value
+     * @return {?}
+     */
+    email(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: Injectable }
+];
+/** @nocollapse */
+FsValidate.ctorParameters = () => [
+    { type: FsUtil }
+];
+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 = { case: 'lower', numbers: true }) {
+    pattern = pattern || 'xxxxxx';
+    /** @type {?} */
+    let 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 {?} */
+    const chars = s.match(/(.{1,1})/g);
+    return pattern.replace(/[x]/g, (/**
+     * @param {?} c
+     * @return {?}
+     */
+    function (c) {
+        /** @type {?} */
+        const 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 === '' ||
+        !toString(value).length ||
+        (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
+ */
+class FsUtilStringifyPipe {
+    constructor() { }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    transform(value) {
+        return stringify(value);
+    }
+}
+FsUtilStringifyPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsUtilStringify'
+            },] }
+];
+/** @nocollapse */
+FsUtilStringifyPipe.ctorParameters = () => [];
+class FsUtilGuidPipe {
+    constructor() { }
+    /**
+     * @return {?}
+     */
+    transform() {
+        return guid();
+    }
+}
+FsUtilGuidPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsUtilGuid'
+            },] }
+];
+/** @nocollapse */
+FsUtilGuidPipe.ctorParameters = () => [];
+class FsUtilIsEmptyPipe {
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    transform(value) {
+        return isEmpty(value);
+    }
+}
+FsUtilIsEmptyPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsUtilIsEmpty'
+            },] }
+];
+class FsUtilIsNotEmptyPipe {
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    transform(value) {
+        return !isEmpty(value);
+    }
+}
+FsUtilIsNotEmptyPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsUtilIsNotEmpty'
+            },] }
+];
+
+/**
+ * @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
+ */
+class FsFormatNumberPipe {
+    /**
+     * @param {?} value
+     * @param {?=} decimals
+     * @return {?}
+     */
+    transform(value, decimals) {
+        return number(value, decimals);
+    }
+}
+FsFormatNumberPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsFormatNumber'
+            },] }
+];
+
+/**
+ * @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 = [2, 10], currencyCode = 'USD', locale = 'en-US') {
+    /** @type {?} */
+    const digitsInfo = isArray(precision) ? precision : [precision, precision];
+    return new 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
+ */
+class FsFormatCurrencyPipe {
+    /**
+     * @param {?} locale
+     */
+    constructor(locale) {
+        this.locale = locale;
+    }
+    /**
+     * @param {?} amount
+     * @param {?=} precision
+     * @param {?=} currencyCode
+     * @return {?}
+     */
+    transform(amount, precision, currencyCode) {
+        return currency(amount, precision, currencyCode);
+    }
+}
+FsFormatCurrencyPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsFormatCurrency'
+            },] }
+];
+/** @nocollapse */
+FsFormatCurrencyPipe.ctorParameters = () => [
+    { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }
+];
+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 = 100, completeWords = false, ellipsis = '...') {
+    value = value || '';
+    if (completeWords) {
+        limit = value.substr(0, limit).lastIndexOf(' ');
+    }
+    /** @type {?} */
+    let 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
+ */
+class FsFormatTruncatePipe {
+    constructor() { }
+    /**
+     * @param {?} value
+     * @param {?=} limit
+     * @param {?=} completeWords
+     * @param {?=} ellipsis
+     * @return {?}
+     */
+    transform(value, limit, completeWords, ellipsis) {
+        return truncate(value, limit, completeWords, ellipsis);
+    }
+}
+FsFormatTruncatePipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsFormatTruncate'
+            },] }
+];
+/** @nocollapse */
+FsFormatTruncatePipe.ctorParameters = () => [];
+
+/**
+ * @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 {?} */
+    const e = Math.floor(Math.log(bytes) / Math.log(1024));
+    /** @type {?} */
+    const 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
+ */
+class FsFormatBytesPipe {
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    transform(value) {
+        return bytes(value);
+    }
+}
+FsFormatBytesPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsFormatBytes',
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/directives/stop-propagation.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsStopPropagationDirective {
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    preventClick(event) {
+        event.stopPropagation();
+    }
+}
+FsStopPropagationDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[fsStopPropagation]',
+            },] }
+];
+FsStopPropagationDirective.propDecorators = {
+    preventClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/directives/prevent-default.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsPreventDefaultDirective {
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    preventClick(event) {
+        event.preventDefault();
+    }
+}
+FsPreventDefaultDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[fsPreventDefault]',
+            },] }
+];
+FsPreventDefaultDirective.propDecorators = {
+    preventClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/directives/autofocus.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsAutofocusDirective {
+    /**
+     * @param {?} _el
+     */
+    constructor(_el) {
+        this._el = _el;
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        setTimeout((/**
+         * @return {?}
+         */
+        () => {
+            this._el.nativeElement.focus();
+        }));
+    }
+}
+FsAutofocusDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[autofocus]',
+            },] }
+];
+/** @nocollapse */
+FsAutofocusDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+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 {?} */
+    const index = value.match `1?.$`;
+    /** @type {?} */
+    const endings = [, 'st', 'nd', 'rd'];
+    /** @type {?} */
+    const ending = endings[index] || 'th';
+    return value + ending;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/pipes/ordinal-number.pipe.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsFormatOrdinalNumberPipe {
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    transform(value) {
+        return ordinalNumber(value);
+    }
+}
+FsFormatOrdinalNumberPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'fsFormatOrdinalNumber',
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: app/fs-common.module.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FsCommonModule {
+    /**
+     * @return {?}
+     */
+    static forRoot() {
+        return {
+            ngModule: FsCommonModule,
+            providers: [
+                FsArray,
+                FsMath,
+                FsUtil,
+                FsValidate
+            ]
+        };
+    }
+}
+FsCommonModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    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,
+                ],
+            },] }
+];
+
+/**
+ * @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 {?} */
+    const 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 {?} */
+    const expression = /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/gm;
+    /** @type {?} */
+    const 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 {?} */
+    let value = true;
+    for (const 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 {?} */
+        const queryObj = query;
+        query = (/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => {
+            return compare(queryObj, item);
+        });
+    }
+    /** @type {?} */
+    const isarray = Array.isArray(array);
+    /** @type {?} */
+    const 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 {?}
+         */
+        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 (let 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 {?} */
+    const 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 {?} */
+        const queryObj = query;
+        query = (/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => {
+            return compare(queryObj, item);
+        });
+    }
+    for (let 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 {?} */
+        const 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 = null) {
+    /** @type {?} */
+    const 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 {?} */
+    const list = [];
+    if (name || value) {
+        /** @type {?} */
+        const nameFn = typeof name === 'function' ? name : (/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            return item[name];
+        });
+        /** @type {?} */
+        const valueFn = typeof value === 'function' ? value : (/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            return item[value];
+        });
+        array.forEach((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            list.push({ name: nameFn(item), value: valueFn(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 {?} */
+    const 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 = false) {
+    if (typeof query !== 'function') {
+        /** @type {?} */
+        const queryStr = query;
+        query = (/**
+         * @param {?} a
+         * @param {?} b
+         * @return {?}
+         */
+        function (a, b) {
+            if (reverse) {
+                if (a[queryStr] < b[queryStr]) {
+                    return 1;
+                }
+                else if (a[queryStr] > b[queryStr]) {
+                    return -1;
+                }
+            }
+            else {
+                if (a[queryStr] > b[queryStr]) {
+                    return 1;
+                }
+                else if (a[queryStr] < b[queryStr]) {
+                    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 {?} */
+    const 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 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 {?} */
+    let timeout;
+    return (/**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        const context = this;
+        /** @type {?} */
+        const args = arguments;
+        /** @type {?} */
+        const later = (/**
+         * @return {?}
+         */
+        function () {
+            timeout = null;
+            if (!immediate)
+                func.apply(context, args);
+        });
+        /** @type {?} */
+        const 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 {?} */
+const KEY_CANCEL$1 = 3;
+/** @type {?} */
+const KEY_HELP$1 = 6;
+/** @type {?} */
+const KEY_BACKSPACE$1 = 8;
+/** @type {?} */
+const KEY_TAB$1 = 9;
+/** @type {?} */
+const KEY_CLEAR$1 = 12;
+/** @type {?} */
+const KEY_RETURN$1 = 13;
+/** @type {?} */
+const KEY_ENTER$1 = 14;
+/** @type {?} */
+const KEY_SHIFT$1 = 16;
+/** @type {?} */
+const KEY_CONTROL$1 = 17;
+/** @type {?} */
+const KEY_ALT$1 = 18;
+/** @type {?} */
+const KEY_PAUSE$1 = 19;
+/** @type {?} */
+const KEY_CAPS_LOCK$1 = 20;
+/** @type {?} */
+const KEY_ESCAPE$1 = 27;
+/** @type {?} */
+const KEY_SPACE$1 = 32;
+/** @type {?} */
+const KEY_PAGE_UP$1 = 33;
+/** @type {?} */
+const KEY_PAGE_DOWN$1 = 34;
+/** @type {?} */
+const KEY_END$1 = 35;
+/** @type {?} */
+const KEY_HOME$1 = 36;
+/** @type {?} */
+const KEY_LEFT$1 = 37;
+/** @type {?} */
+const KEY_UP$1 = 38;
+/** @type {?} */
+const KEY_RIGHT$1 = 39;
+/** @type {?} */
+const KEY_DOWN$1 = 40;
+/** @type {?} */
+const KEY_PRINTSCREEN$1 = 44;
+/** @type {?} */
+const KEY_INSERT$1 = 45;
+/** @type {?} */
+const KEY_DELETE$1 = 46;
+/** @type {?} */
+const KEY_0$1 = 48;
+/** @type {?} */
+const KEY_1$1 = 49;
+/** @type {?} */
+const KEY_2$1 = 50;
+/** @type {?} */
+const KEY_3$1 = 51;
+/** @type {?} */
+const KEY_4$1 = 52;
+/** @type {?} */
+const KEY_5$1 = 53;
+/** @type {?} */
+const KEY_6$1 = 54;
+/** @type {?} */
+const KEY_7$1 = 55;
+/** @type {?} */
+const KEY_8$1 = 56;
+/** @type {?} */
+const KEY_9$1 = 57;
+/** @type {?} */
+const KEY_SEMICOLON$1 = 59;
+/** @type {?} */
+const 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 (isObject(object)) {
+        return Object.keys(object).length;
+    }
+    if (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 = []) {
+    /** @type {?} */
+    const result = defaults;
+    return new Promise((/**
+     * @param {?} resolve
+     * @return {?}
+     */
+    resolve => {
+        promise.then((/**
+         * @param {?} data
+         * @return {?}
+         */
+        function (data) {
+            Object.keys(data).forEach((/**
+             * @param {?} key
+             * @return {?}
+             */
+            key => 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 {?} */
+    const str = 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 {?} */
+    let 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
+ */
+class Operation {
+    /**
+     * @param {?} target
+     * @param {?=} name
+     */
+    constructor(target, name) {
+        this.ready$ = new Subject();
+        this.name = name ? name : guid();
+        if (target instanceof Observable) {
+            this.target = target;
+        }
+        else {
+            this.target = of(target);
+        }
+    }
+}
+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} */
+const 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
+ */
+class Queue {
+    /**
+     * @param {?=} _limit
+     */
+    constructor(_limit = Infinity) {
+        this._limit = _limit;
+        this._done = new Subject();
+        this._queue = [];
+        this._inProgress = [];
+        this._total = 0;
+        this._completed = 0;
+        this._errors = 0;
+        this._state = QueueState.Idle;
+        this._destroy$ = new Subject();
+    }
+    /**
+     * @return {?}
+     */
+    get total() {
+        return this._total;
+    }
+    /**
+     * @return {?}
+     */
+    get completed() {
+        return this._completed;
+    }
+    /**
+     * @return {?}
+     */
+    get pending() {
+        return this._queue.length;
+    }
+    /**
+     * @return {?}
+     */
+    get inProgress() {
+        return this._inProgress.length;
+    }
+    /**
+     * @return {?}
+     */
+    get errors() {
+        return this._errors;
+    }
+    /**
+     * @return {?}
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * @return {?}
+     */
+    get empty() {
+        return !this._queue.length && !this._inProgress.length;
+    }
+    /**
+     * @return {?}
+     */
+    get pendingOperations() {
+        return this._queue
+            .map((/**
+         * @param {?} operation
+         * @return {?}
+         */
+        (operation) => operation.name));
+    }
+    /**
+     * @return {?}
+     */
+    get inProgressOperations() {
+        return this._inProgress
+            .map((/**
+         * @param {?} operation
+         * @return {?}
+         */
+        (operation) => operation.name));
+    }
+    /**
+     * @return {?}
+     */
+    isProcessing() {
+        return this._state === QueueState.Processing;
+    }
+    /**
+     * @return {?}
+     */
+    isIdle() {
+        return this._state === QueueState.Idle;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    setLimit(value) {
+        this._limit = value;
+    }
+    /**
+     * @param {?} fun
+     * @param {?=} err
+     * @param {?=} complete
+     * @return {?}
+     */
+    subscribe(fun, err, complete) {
+        this._done
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(fun, err, complete);
+    }
+    /**
+     * @param {?} fun
+     * @param {?=} err
+     * @param {?=} complete
+     * @return {?}
+     */
+    complete(fun, err, complete) {
+        Observable.create((/**
+         * @param {?} observer
+         * @return {?}
+         */
+        observer => {
+            if (!this.isProcessing()) {
+                observer.next();
+                observer.complete();
+                return;
+            }
+            this.subscribe((/**
+             * @return {?}
+             */
+            () => {
+                observer.next();
+                observer.complete();
+            }), (/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                observer.error(error);
+                this.clear();
+            }));
+        })).subscribe(fun, err, complete);
+    }
+    /**
+     * @param {?} target
+     * @param {?=} name
+     * @return {?}
+     */
+    push(target, name) {
+        /** @type {?} */
+        const 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 {?}
+     */
+    clear() {
+        this._queue = [];
+        this._total = 0;
+        this._errors = 0;
+        this._completed = 0;
+        this._state = QueueState.Idle;
+        this._done = new Subject();
+    }
+    /**
+     * @return {?}
+     */
+    destroy() {
+        this.clear();
+        this._done.complete();
+    }
+    /**
+     * @private
+     * @param {?} operation
+     * @return {?}
+     */
+    _processOperation(operation) {
+        this._inProgress.push(operation);
+        operation.target
+            .pipe(delay(200), // Hack to prevent extra quick proccess execution
+        takeUntil(this._destroy$)).subscribe({
+            next: (/**
+             * @param {?} data
+             * @return {?}
+             */
+            (data) => {
+                operation.ready$.next(data);
+            }),
+            error: (/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                /** @type {?} */
+                const 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 {?}
+             */
+            () => {
+                /** @type {?} */
+                const 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 {?} */
+                        const queueItem = this._queue.shift();
+                        this._processOperation(queueItem);
+                    }
+                }
+            })
+        });
+    }
+}
+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 {?} */
+    const 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 = 2) {
+    /** @type {?} */
+    const splittedString = str
+        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .split(' ');
+    /** @type {?} */
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        if (!splittedString[i]) {
+            if (splittedString.length === 1) {
+                for (let 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 = 5, message) {
+    /** @type {?} */
+    let retries = 0;
+    return (/**
+     * @param {?} src
+     * @return {?}
+     */
+    (src) => src.pipe(retryWhen((/**
+     * @param {?} errors
+     * @return {?}
+     */
+    (errors) => errors.pipe(tap((/**
+     * @return {?}
+     */
+    () => {
+        retries++;
+        if (retries <= maxRetry) {
+            console.info(`Failed to load Resource. Retry in ${delayMs / 1000} sec. ${retries}/${maxRetry} times...`);
+        }
+    })), concatMap((/**
+     * @param {?} error
+     * @return {?}
+     */
+    (error) => iif((/**
+     * @return {?}
+     */
+    () => retries > maxRetry), throwError(getErrorMessage(maxRetry, message)), timer(delayMs)))))))));
+}
+/** @type {?} */
+const getErrorMessage = (/**
+ * @param {?} maxRetry
+ * @param {?} defaultMessage
+ * @return {?}
+ */
+(maxRetry, defaultMessage) => {
+    if (!defaultMessage) {
+        return `Failed to load Resource for ${maxRetry} times. Giving up.`;
+    }
+    else {
+        return defaultMessage;
+    }
+});
+const ɵ0 = getErrorMessage;
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: libs/index.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: firestitch-common.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { FsArray, FsCommonModule, FsMath, FsUtil, FsValidate, KEY_0$1 as KEY_0, KEY_1$1 as KEY_1, KEY_2$1 as KEY_2, KEY_3$1 as KEY_3, KEY_4$1 as KEY_4, KEY_5$1 as KEY_5, KEY_6$1 as KEY_6, KEY_7$1 as KEY_7, KEY_8$1 as KEY_8, KEY_9$1 as KEY_9, KEY_ALT$1 as KEY_ALT, KEY_BACKSPACE$1 as KEY_BACKSPACE, KEY_CANCEL$1 as KEY_CANCEL, KEY_CAPS_LOCK$1 as KEY_CAPS_LOCK, KEY_CLEAR$1 as KEY_CLEAR, KEY_CONTROL$1 as KEY_CONTROL, KEY_DELETE$1 as KEY_DELETE, KEY_DOWN$1 as KEY_DOWN, KEY_END$1 as KEY_END, KEY_ENTER$1 as KEY_ENTER, KEY_EQUALS$1 as KEY_EQUALS, KEY_ESCAPE$1 as KEY_ESCAPE, KEY_HELP$1 as KEY_HELP, KEY_HOME$1 as KEY_HOME, KEY_INSERT$1 as KEY_INSERT, KEY_LEFT$1 as KEY_LEFT, KEY_PAGE_DOWN$1 as KEY_PAGE_DOWN, KEY_PAGE_UP$1 as KEY_PAGE_UP, KEY_PAUSE$1 as KEY_PAUSE, KEY_PRINTSCREEN$1 as KEY_PRINTSCREEN, KEY_RETURN$1 as KEY_RETURN, KEY_RIGHT$1 as KEY_RIGHT, KEY_SEMICOLON$1 as KEY_SEMICOLON, KEY_SHIFT$1 as KEY_SHIFT, KEY_SPACE$1 as KEY_SPACE, KEY_TAB$1 as KEY_TAB, KEY_UP$1 as KEY_UP, Queue, QueueState, acronym, boolean, bytes, compare, currency, debounce, delayedRetry, email, filter, find, getNormalizedPath, guid, inArray, index, indexOf, isClass, isEmpty, isNumeric, keyExists, ksort, length, list, nameValue, number, ordinalNumber, phone, remove, removeQueryParams, resolve, rsort, sort, stringify, throttle, truncate, url, uuid, value, FsStopPropagationDirective as ɵa, FsPreventDefaultDirective as ɵb, FsAutofocusDirective as ɵc, FsUtilStringifyPipe as ɵd, FsUtilGuidPipe as ɵe, FsUtilIsEmptyPipe as ɵf, FsUtilIsNotEmptyPipe as ɵg, FsFormatNumberPipe as ɵh, FsFormatCurrencyPipe as ɵi, FsFormatTruncatePipe as ɵj, FsFormatBytesPipe as ɵk, FsFormatOrdinalNumberPipe as ɵl };
+//# sourceMappingURL=firestitch-common.js.map