ngx-bootstrap 3.0.1 → 3.1.4

package/utils/bundles/ngx-bootstrap-utils.umd.js

@@ -0,0 +1,792 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/utils', ['exports', '@angular/core'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].utils = {}),global.ng.core));
+}(this, (function (exports,core) { 'use strict';
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @copyright Valor Software
+     * @copyright Angular ng-bootstrap team
+     */
+    var Trigger = (function () {
+        function Trigger(open, close) {
+            this.open = open;
+            this.close = close || open;
+        }
+        /**
+         * @return {?}
+         */
+        Trigger.prototype.isManual = /**
+         * @return {?}
+         */
+            function () {
+                return this.open === 'manual' || this.close === 'manual';
+            };
+        return Trigger;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ DEFAULT_ALIASES = {
+        hover: ['mouseover', 'mouseout'],
+        focus: ['focusin', 'focusout']
+    };
+    /**
+     * @param {?} triggers
+     * @param {?=} aliases
+     * @return {?}
+     */
+    function parseTriggers(triggers, aliases) {
+        if (aliases === void 0) {
+            aliases = DEFAULT_ALIASES;
+        }
+        var /** @type {?} */ trimmedTriggers = (triggers || '').trim();
+        if (trimmedTriggers.length === 0) {
+            return [];
+        }
+        var /** @type {?} */ parsedTriggers = trimmedTriggers
+            .split(/\s+/)
+            .map(function (trigger) { return trigger.split(':'); })
+            .map(function (triggerPair) {
+            var /** @type {?} */ alias = aliases[triggerPair[0]] || triggerPair;
+            return new Trigger(alias[0], alias[1]);
+        });
+        var /** @type {?} */ manualTriggers = parsedTriggers.filter(function (triggerPair) {
+            return triggerPair.isManual();
+        });
+        if (manualTriggers.length > 1) {
+            throw new Error('Triggers parse error: only one manual trigger is allowed');
+        }
+        if (manualTriggers.length === 1 && parsedTriggers.length > 1) {
+            throw new Error('Triggers parse error: manual trigger can\'t be mixed with other triggers');
+        }
+        return parsedTriggers;
+    }
+    /**
+     * @param {?} renderer
+     * @param {?} target
+     * @param {?} triggers
+     * @param {?} showFn
+     * @param {?} hideFn
+     * @param {?} toggleFn
+     * @return {?}
+     */
+    function listenToTriggers(renderer, /* tslint:disable-next-line: no-any */ 
+    /* tslint:disable-next-line: no-any */
+    target, triggers, showFn, hideFn, toggleFn) {
+        var /** @type {?} */ parsedTriggers = parseTriggers(triggers);
+        /* tslint:disable-next-line: no-any */
+        var /** @type {?} */ listeners = [];
+        if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {
+            return Function.prototype;
+        }
+        parsedTriggers.forEach(function (trigger) {
+            if (trigger.open === trigger.close) {
+                listeners.push(renderer.listen(target, trigger.open, toggleFn));
+                return;
+            }
+            listeners.push(renderer.listen(target, trigger.open, showFn), renderer.listen(target, trigger.close, hideFn));
+        });
+        return function () {
+            listeners.forEach(function (unsubscribeFn) { return unsubscribeFn(); });
+        };
+    }
+    /**
+     * @param {?} renderer
+     * @param {?} options
+     * @return {?}
+     */
+    function listenToTriggersV2(renderer, options) {
+        var /** @type {?} */ parsedTriggers = parseTriggers(options.triggers);
+        var /** @type {?} */ target = options.target;
+        // do nothing
+        if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {
+            return Function.prototype;
+        }
+        // all listeners
+        /* tslint:disable-next-line: no-any */
+        var /** @type {?} */ listeners = [];
+        // lazy listeners registration
+        var /** @type {?} */ _registerHide = [];
+        var /** @type {?} */ registerHide = function () {
+            // add hide listeners to unregister array
+            _registerHide.forEach(function (fn) { return listeners.push(fn()); });
+            // register hide events only once
+            _registerHide.length = 0;
+        };
+        // register open\close\toggle listeners
+        parsedTriggers.forEach(function (trigger) {
+            var /** @type {?} */ useToggle = trigger.open === trigger.close;
+            var /** @type {?} */ showFn = useToggle ? options.toggle : options.show;
+            if (!useToggle) {
+                _registerHide.push(function () {
+                    return renderer.listen(target, trigger.close, options.hide);
+                });
+            }
+            listeners.push(renderer.listen(target, trigger.open, function () { return showFn(registerHide); }));
+        });
+        return function () {
+            listeners.forEach(function (unsubscribeFn) { return unsubscribeFn(); });
+        };
+    }
+    /**
+     * @param {?} renderer
+     * @param {?} options
+     * @return {?}
+     */
+    function registerOutsideClick(renderer, options) {
+        if (!options.outsideClick) {
+            return Function.prototype;
+        }
+        /* tslint:disable-next-line: no-any */
+        return renderer.listen('document', 'click', function (event) {
+            if (options.target && options.target.contains(event.target)) {
+                return undefined;
+            }
+            if (options.targets &&
+                options.targets.some(function (target) { return target.contains(event.target); })) {
+                return undefined;
+            }
+            options.hide();
+        });
+    }
+    /**
+     * @param {?} renderer
+     * @param {?} options
+     * @return {?}
+     */
+    function registerEscClick(renderer, options) {
+        if (!options.outsideEsc) {
+            return Function.prototype;
+        }
+        return renderer.listen('document', 'keyup.esc', function (event) {
+            if (options.target && options.target.contains(event.target)) {
+                return undefined;
+            }
+            if (options.targets &&
+                options.targets.some(function (target) { return target.contains(event.target); })) {
+                return undefined;
+            }
+            options.hide();
+        });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * JS version of browser APIs. This library can only run in the browser.
+     */
+    var /** @type {?} */ win = (typeof window !== 'undefined' && window) || /** @type {?} */ ({});
+    var /** @type {?} */ document$1 = win.document;
+    var /** @type {?} */ location = win.location;
+    var /** @type {?} */ gc = win.gc ? function () { return win.gc(); } : function () { return null; };
+    var /** @type {?} */ performance = win.performance ? win.performance : null;
+    var /** @type {?} */ Event = win.Event;
+    var /** @type {?} */ MouseEvent = win.MouseEvent;
+    var /** @type {?} */ KeyboardEvent = win.KeyboardEvent;
+    var /** @type {?} */ EventTarget = win.EventTarget;
+    var /** @type {?} */ History = win.History;
+    var /** @type {?} */ Location = win.Location;
+    var /** @type {?} */ EventListener = win.EventListener;
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ guessedVersion;
+    /**
+     * @return {?}
+     */
+    function _guessBsVersion() {
+        if (typeof document === 'undefined') {
+            return null;
+        }
+        var /** @type {?} */ spanEl = document.createElement('span');
+        spanEl.innerText = 'test bs version';
+        document.body.appendChild(spanEl);
+        spanEl.classList.add('d-none');
+        var /** @type {?} */ rect = spanEl.getBoundingClientRect();
+        document.body.removeChild(spanEl);
+        if (!rect) {
+            return 'bs3';
+        }
+        return rect.top === 0 ? 'bs4' : 'bs3';
+    }
+    /**
+     * @param {?} theme
+     * @return {?}
+     */
+    function setTheme(theme) {
+        guessedVersion = theme;
+    }
+    /**
+     * @return {?}
+     */
+    function isBs3() {
+        if (typeof win === 'undefined') {
+            return true;
+        }
+        if (typeof win.__theme === 'undefined') {
+            if (guessedVersion) {
+                return guessedVersion === 'bs3';
+            }
+            guessedVersion = _guessBsVersion();
+            return guessedVersion === 'bs3';
+        }
+        return win.__theme !== 'bs4';
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @template T
+     */
+    var /**
+     * @template T
+     */ LinkedList = (function () {
+        function LinkedList() {
+            this.length = 0;
+            this.asArray = [];
+        }
+        /**
+         * @param {?} position
+         * @return {?}
+         */
+        LinkedList.prototype.get = /**
+         * @param {?} position
+         * @return {?}
+         */
+            function (position) {
+                if (this.length === 0 || position < 0 || position >= this.length) {
+                    return void 0;
+                }
+                var /** @type {?} */ current = this.head;
+                for (var /** @type {?} */ index = 0; index < position; index++) {
+                    current = current.next;
+                }
+                return current.value;
+            };
+        /**
+         * @param {?} value
+         * @param {?=} position
+         * @return {?}
+         */
+        LinkedList.prototype.add = /**
+         * @param {?} value
+         * @param {?=} position
+         * @return {?}
+         */
+            function (value, position) {
+                if (position === void 0) {
+                    position = this.length;
+                }
+                if (position < 0 || position > this.length) {
+                    throw new Error('Position is out of the list');
+                }
+                /* tslint:disable-next-line: no-any*/
+                var /** @type {?} */ node = {
+                    value: value,
+                    next: undefined,
+                    previous: undefined
+                };
+                if (this.length === 0) {
+                    this.head = node;
+                    this.tail = node;
+                    this.current = node;
+                }
+                else {
+                    if (position === 0) {
+                        // first node
+                        node.next = this.head;
+                        this.head.previous = node;
+                        this.head = node;
+                    }
+                    else if (position === this.length) {
+                        // last node
+                        this.tail.next = node;
+                        node.previous = this.tail;
+                        this.tail = node;
+                    }
+                    else {
+                        // node in middle
+                        var /** @type {?} */ currentPreviousNode = this.getNode(position - 1);
+                        var /** @type {?} */ currentNextNode = currentPreviousNode.next;
+                        currentPreviousNode.next = node;
+                        currentNextNode.previous = node;
+                        node.previous = currentPreviousNode;
+                        node.next = currentNextNode;
+                    }
+                }
+                this.length++;
+                this.createInternalArrayRepresentation();
+            };
+        /**
+         * @param {?=} position
+         * @return {?}
+         */
+        LinkedList.prototype.remove = /**
+         * @param {?=} position
+         * @return {?}
+         */
+            function (position) {
+                if (position === void 0) {
+                    position = 0;
+                }
+                if (this.length === 0 || position < 0 || position >= this.length) {
+                    throw new Error('Position is out of the list');
+                }
+                if (position === 0) {
+                    // first node
+                    this.head = this.head.next;
+                    if (this.head) {
+                        // there is no second node
+                        this.head.previous = undefined;
+                    }
+                    else {
+                        // there is no second node
+                        this.tail = undefined;
+                    }
+                }
+                else if (position === this.length - 1) {
+                    // last node
+                    this.tail = this.tail.previous;
+                    this.tail.next = undefined;
+                }
+                else {
+                    // middle node
+                    var /** @type {?} */ removedNode = this.getNode(position);
+                    removedNode.next.previous = removedNode.previous;
+                    removedNode.previous.next = removedNode.next;
+                }
+                this.length--;
+                this.createInternalArrayRepresentation();
+            };
+        /**
+         * @param {?} position
+         * @param {?} value
+         * @return {?}
+         */
+        LinkedList.prototype.set = /**
+         * @param {?} position
+         * @param {?} value
+         * @return {?}
+         */
+            function (position, value) {
+                if (this.length === 0 || position < 0 || position >= this.length) {
+                    throw new Error('Position is out of the list');
+                }
+                var /** @type {?} */ node = this.getNode(position);
+                node.value = value;
+                this.createInternalArrayRepresentation();
+            };
+        /**
+         * @return {?}
+         */
+        LinkedList.prototype.toArray = /**
+         * @return {?}
+         */
+            function () {
+                return this.asArray;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.findAll = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                /* tslint:disable-next-line: no-any*/
+                var /** @type {?} */ result = [];
+                for (var /** @type {?} */ index = 0; index < this.length; index++) {
+                    if (fn(current.value, index)) {
+                        result.push({ index: index, value: current.value });
+                    }
+                    current = current.next;
+                }
+                return result;
+            };
+        // Array methods overriding start
+        /**
+         * @param {...?} args
+         * @return {?}
+         */
+        LinkedList.prototype.push = /**
+         * @param {...?} args
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                /* tslint:disable-next-line: no-any*/
+                args.forEach(function (arg) {
+                    _this.add(arg);
+                });
+                return this.length;
+            };
+        /**
+         * @return {?}
+         */
+        LinkedList.prototype.pop = /**
+         * @return {?}
+         */
+            function () {
+                if (this.length === 0) {
+                    return undefined;
+                }
+                var /** @type {?} */ last = this.tail;
+                this.remove(this.length - 1);
+                return last.value;
+            };
+        /**
+         * @param {...?} args
+         * @return {?}
+         */
+        LinkedList.prototype.unshift = /**
+         * @param {...?} args
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                args.reverse();
+                /* tslint:disable-next-line: no-any*/
+                args.forEach(function (arg) {
+                    _this.add(arg, 0);
+                });
+                return this.length;
+            };
+        /**
+         * @return {?}
+         */
+        LinkedList.prototype.shift = /**
+         * @return {?}
+         */
+            function () {
+                if (this.length === 0) {
+                    return undefined;
+                }
+                var /** @type {?} */ lastItem = this.head.value;
+                this.remove();
+                return lastItem;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.forEach = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                for (var /** @type {?} */ index = 0; index < this.length; index++) {
+                    fn(current.value, index);
+                    current = current.next;
+                }
+            };
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        LinkedList.prototype.indexOf = /**
+         * @param {?} value
+         * @return {?}
+         */
+            function (value) {
+                var /** @type {?} */ current = this.head;
+                var /** @type {?} */ position = 0;
+                for (var /** @type {?} */ index = 0; index < this.length; index++) {
+                    if (current.value === value) {
+                        position = index;
+                        break;
+                    }
+                    current = current.next;
+                }
+                return position;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.some = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                var /** @type {?} */ result = false;
+                while (current && !result) {
+                    if (fn(current.value)) {
+                        result = true;
+                        break;
+                    }
+                    current = current.next;
+                }
+                return result;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.every = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                var /** @type {?} */ result = true;
+                while (current && result) {
+                    if (!fn(current.value)) {
+                        result = false;
+                    }
+                    current = current.next;
+                }
+                return result;
+            };
+        /**
+         * @return {?}
+         */
+        LinkedList.prototype.toString = /**
+         * @return {?}
+         */
+            function () {
+                return '[Linked List]';
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.find = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                var /** @type {?} */ result;
+                for (var /** @type {?} */ index = 0; index < this.length; index++) {
+                    if (fn(current.value, index)) {
+                        result = current.value;
+                        break;
+                    }
+                    current = current.next;
+                }
+                return result;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} fn
+         * @return {?}
+         */
+        LinkedList.prototype.findIndex = /**
+         * @param {?} fn
+         * @return {?}
+         */
+            function (fn) {
+                var /** @type {?} */ current = this.head;
+                var /** @type {?} */ result;
+                for (var /** @type {?} */ index = 0; index < this.length; index++) {
+                    if (fn(current.value, index)) {
+                        result = index;
+                        break;
+                    }
+                    current = current.next;
+                }
+                return result;
+            };
+        /* tslint:disable-next-line: no-any*/
+        /**
+         * @param {?} position
+         * @return {?}
+         */
+        LinkedList.prototype.getNode = /**
+         * @param {?} position
+         * @return {?}
+         */
+            function (position) {
+                if (this.length === 0 || position < 0 || position >= this.length) {
+                    throw new Error('Position is out of the list');
+                }
+                var /** @type {?} */ current = this.head;
+                for (var /** @type {?} */ index = 0; index < position; index++) {
+                    current = current.next;
+                }
+                return current;
+            };
+        /**
+         * @return {?}
+         */
+        LinkedList.prototype.createInternalArrayRepresentation = /**
+         * @return {?}
+         */
+            function () {
+                /* tslint:disable-next-line: no-any*/
+                var /** @type {?} */ outArray = [];
+                var /** @type {?} */ current = this.head;
+                while (current) {
+                    outArray.push(current.value);
+                    current = current.next;
+                }
+                this.asArray = outArray;
+            };
+        return LinkedList;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?=} defaultValue
+     * @return {?}
+     */
+    function OnChange(defaultValue) {
+        var /** @type {?} */ sufix = 'Change';
+        /* tslint:disable-next-line: no-any */
+        return function OnChangeHandler(target, propertyKey) {
+            var /** @type {?} */ _key = " __" + propertyKey + "Value";
+            Object.defineProperty(target, propertyKey, {
+                /* tslint:disable-next-line: no-any */
+                get: /**
+                 * @return {?}
+                 */ function () {
+                    return this[_key];
+                },
+                /* tslint:disable-next-line: no-any */
+                set: /**
+                 * @param {?} value
+                 * @return {?}
+                 */ function (value) {
+                    var /** @type {?} */ prevValue = this[_key];
+                    this[_key] = value;
+                    if (prevValue !== value && this[propertyKey + sufix]) {
+                        this[propertyKey + sufix].emit(value);
+                    }
+                }
+            });
+        };
+    }
+    /* tslint:enable */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var Utils = (function () {
+        function Utils() {
+        }
+        /* tslint:disable-next-line: no-any */
+        /**
+         * @param {?} element
+         * @return {?}
+         */
+        Utils.reflow = /**
+         * @param {?} element
+         * @return {?}
+         */
+            function (element) {
+                /* tslint:disable-next-line: no-any */
+                (function (bs) { return bs; })(element.offsetHeight);
+            };
+        // source: https://github.com/jquery/jquery/blob/master/src/css/var/getStyles.js
+        /* tslint:disable-next-line: no-any */
+        /**
+         * @param {?} elem
+         * @return {?}
+         */
+        Utils.getStyles = /**
+         * @param {?} elem
+         * @return {?}
+         */
+            function (elem) {
+                // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+                // IE throws on elements created in popups
+                // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+                var /** @type {?} */ view = elem.ownerDocument.defaultView;
+                if (!view || !view.opener) {
+                    view = win;
+                }
+                return view.getComputedStyle(elem);
+            };
+        return Utils;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ _messagesHash = {};
+    var /** @type {?} */ _hideMsg = typeof console === 'undefined' || !('warn' in console);
+    /**
+     * @param {?} msg
+     * @return {?}
+     */
+    function warnOnce(msg) {
+        if (!core.isDevMode() || _hideMsg || msg in _messagesHash) {
+            return;
+        }
+        _messagesHash[msg] = true;
+        /*tslint:disable-next-line*/
+        console.warn(msg);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    exports.isBs3 = isBs3;
+    exports.LinkedList = LinkedList;
+    exports.listenToTriggersV2 = listenToTriggersV2;
+    exports.registerOutsideClick = registerOutsideClick;
+    exports.registerEscClick = registerEscClick;
+    exports.OnChange = OnChange;
+    exports.setTheme = setTheme;
+    exports.Trigger = Trigger;
+    exports.Utils = Utils;
+    exports.window = win;
+    exports.document = document$1;
+    exports.warnOnce = warnOnce;
+    exports.parseTriggers = parseTriggers;
+    exports.listenToTriggers = listenToTriggers;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-utils.umd.js.map","sources":["ng://ngx-bootstrap/utils/trigger.class.ts","ng://ngx-bootstrap/utils/triggers.ts","ng://ngx-bootstrap/utils/facade/browser.ts","ng://ngx-bootstrap/utils/theme-provider.ts","ng://ngx-bootstrap/utils/linked-list.class.ts","ng://ngx-bootstrap/utils/decorators.ts","ng://ngx-bootstrap/utils/utils.class.ts","ng://ngx-bootstrap/utils/warn-once.ts"],"sourcesContent":["/**\n * @copyright Valor Software\n * @copyright Angular ng-bootstrap team\n */\n\nexport class Trigger {\n  open: string;\n  close?: string;\n\n  constructor(open: string, close?: string) {\n    this.open = open;\n    this.close = close || open;\n  }\n\n  isManual(): boolean {\n    return this.open === 'manual' || this.close === 'manual';\n  }\n}\n","/**\n * @copyright Valor Software\n * @copyright Angular ng-bootstrap team\n */\nimport { Renderer2 } from '@angular/core';\nimport { Trigger } from './trigger.class';\n\n/* tslint:disable-next-line: no-any */\nexport type BsEventCallback = (event?: any) => boolean | void;\n\nexport interface ListenOptions {\n  target?: HTMLElement;\n  targets?: HTMLElement[];\n  triggers?: string;\n  outsideClick?: boolean;\n  outsideEsc?: boolean;\n  show?: BsEventCallback;\n  hide?: BsEventCallback;\n  toggle?: BsEventCallback;\n}\n\nconst DEFAULT_ALIASES = {\n  hover: ['mouseover', 'mouseout'],\n  focus: ['focusin', 'focusout']\n};\n\n/* tslint:disable-next-line: no-any */\nexport function parseTriggers(triggers: string, aliases: any = DEFAULT_ALIASES): Trigger[] {\n  const trimmedTriggers = (triggers || '').trim();\n\n  if (trimmedTriggers.length === 0) {\n    return [];\n  }\n\n  const parsedTriggers = trimmedTriggers\n    .split(/\\s+/)\n    .map((trigger: string) => trigger.split(':'))\n    .map((triggerPair: string[]) => {\n      const alias = aliases[triggerPair[0]] || triggerPair;\n\n      return new Trigger(alias[0], alias[1]);\n    });\n\n  const manualTriggers = parsedTriggers.filter((triggerPair: Trigger) =>\n    triggerPair.isManual()\n  );\n\n  if (manualTriggers.length > 1) {\n    throw new Error('Triggers parse error: only one manual trigger is allowed');\n  }\n\n  if (manualTriggers.length === 1 && parsedTriggers.length > 1) {\n    throw new Error('Triggers parse error: manual trigger can\\'t be mixed with other triggers');\n  }\n\n  return parsedTriggers;\n}\n\nexport function listenToTriggers(renderer: Renderer2,\n                                 /* tslint:disable-next-line: no-any */\n                                 target: any,\n                                 triggers: string,\n                                 showFn: BsEventCallback,\n                                 hideFn: BsEventCallback,\n                                 toggleFn: BsEventCallback): Function {\n  const parsedTriggers = parseTriggers(triggers);\n  /* tslint:disable-next-line: no-any */\n  const listeners: any[] = [];\n\n  if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {\n    return Function.prototype;\n  }\n\n  parsedTriggers.forEach((trigger: Trigger) => {\n    if (trigger.open === trigger.close) {\n      listeners.push(renderer.listen(target, trigger.open, toggleFn));\n\n      return;\n    }\n\n    listeners.push(\n      renderer.listen(target, trigger.open, showFn),\n      renderer.listen(target, trigger.close, hideFn)\n    );\n  });\n\n  return () => {\n    listeners.forEach((unsubscribeFn: Function) => unsubscribeFn());\n  };\n}\n\nexport function listenToTriggersV2(renderer: Renderer2,\n                                   options: ListenOptions): Function {\n  const parsedTriggers = parseTriggers(options.triggers);\n  const target = options.target;\n  // do nothing\n  if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {\n    return Function.prototype;\n  }\n\n  // all listeners\n  /* tslint:disable-next-line: no-any */\n  const listeners: any[] = [];\n\n  // lazy listeners registration\n  const _registerHide: Function[] = [];\n  const registerHide = () => {\n    // add hide listeners to unregister array\n    _registerHide.forEach((fn: Function) => listeners.push(fn()));\n    // register hide events only once\n    _registerHide.length = 0;\n  };\n\n  // register open\\close\\toggle listeners\n  parsedTriggers.forEach((trigger: Trigger) => {\n    const useToggle = trigger.open === trigger.close;\n    const showFn = useToggle ? options.toggle : options.show;\n\n    if (!useToggle) {\n      _registerHide.push(() =>\n        renderer.listen(target, trigger.close, options.hide)\n      );\n    }\n\n    listeners.push(\n      renderer.listen(target, trigger.open, () => showFn(registerHide))\n    );\n  });\n\n  return () => {\n    listeners.forEach((unsubscribeFn: Function) => unsubscribeFn());\n  };\n}\n\nexport function registerOutsideClick(renderer: Renderer2,\n                                     options: ListenOptions) {\n  if (!options.outsideClick) {\n    return Function.prototype;\n  }\n\n  /* tslint:disable-next-line: no-any */\n  return renderer.listen('document', 'click', (event: any) => {\n    if (options.target && options.target.contains(event.target)) {\n      return undefined;\n    }\n    if (\n      options.targets &&\n      options.targets.some(target => target.contains(event.target))\n    ) {\n      return undefined;\n    }\n\n    options.hide();\n  });\n}\n\nexport function registerEscClick(renderer: Renderer2,\n                                 options: ListenOptions) {\n  if (!options.outsideEsc) {\n    return Function.prototype;\n  }\n\n  return renderer.listen('document', 'keyup.esc', (event: any) => {\n    if (options.target && options.target.contains(event.target)) {\n      return undefined;\n    }\n    if (\n      options.targets &&\n      options.targets.some(target => target.contains(event.target))\n    ) {\n      return undefined;\n    }\n\n    options.hide();\n  });\n}\n","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * JS version of browser APIs. This library can only run in the browser.\n */\nconst win = (typeof window !== 'undefined' && window) || {} as any;\n\nexport { win as window };\nexport const document = win.document;\nexport const location = win.location;\nexport const gc = win.gc ? () => win.gc() : (): any => null;\nexport const performance = win.performance ? win.performance : null;\nexport const Event = win.Event;\nexport const MouseEvent = win.MouseEvent;\nexport const KeyboardEvent = win.KeyboardEvent;\nexport const EventTarget = win.EventTarget;\nexport const History = win.History;\nexport const Location = win.Location;\nexport const EventListener = win.EventListener;\n","import { window } from './facade/browser';\n\nlet guessedVersion: 'bs3' | 'bs4';\n\nfunction _guessBsVersion(): 'bs3' | 'bs4' {\n  if (typeof document === 'undefined') {\n    return null;\n  }\n  const spanEl = document.createElement('span');\n  spanEl.innerText = 'test bs version';\n  document.body.appendChild(spanEl);\n  spanEl.classList.add('d-none');\n  const rect = spanEl.getBoundingClientRect();\n  document.body.removeChild(spanEl);\n  if (!rect) {\n    return 'bs3';\n  }\n\n  return rect.top === 0 ? 'bs4' : 'bs3';\n}\n\nexport function setTheme(theme: 'bs3' | 'bs4'): void {\n  guessedVersion = theme;\n}\n\n// todo: in ngx-bootstrap, bs4 will became a default one\nexport function isBs3(): boolean {\n  if (typeof window === 'undefined') {\n    return true;\n  }\n\n  if (typeof window.__theme === 'undefined') {\n    if (guessedVersion) {\n      return guessedVersion === 'bs3';\n    }\n    guessedVersion = _guessBsVersion();\n\n    return guessedVersion === 'bs3';\n  }\n\n  return window.__theme !== 'bs4';\n}\n","export class LinkedList<T> {\n  length = 0;\n  /* tslint:disable-next-line: no-any*/\n  protected head: any;\n  /* tslint:disable-next-line: no-any*/\n  protected tail: any;\n  /* tslint:disable-next-line: no-any*/\n  protected current: any;\n  protected asArray: T[] = [];\n\n  get(position: number): T {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      return void 0;\n    }\n\n    let current = this.head;\n\n    for (let index = 0; index < position; index++) {\n      current = current.next;\n    }\n\n    return current.value;\n  }\n\n  add(value: T, position: number = this.length): void {\n    if (position < 0 || position > this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    /* tslint:disable-next-line: no-any*/\n    const node: any = {\n      value,\n      next: undefined,\n      previous: undefined\n    };\n\n    if (this.length === 0) {\n      this.head = node;\n      this.tail = node;\n      this.current = node;\n    } else {\n      if (position === 0) {\n        // first node\n        node.next = this.head;\n        this.head.previous = node;\n        this.head = node;\n      } else if (position === this.length) {\n        // last node\n        this.tail.next = node;\n        node.previous = this.tail;\n        this.tail = node;\n      } else {\n        // node in middle\n        const currentPreviousNode = this.getNode(position - 1);\n        const currentNextNode = currentPreviousNode.next;\n\n        currentPreviousNode.next = node;\n        currentNextNode.previous = node;\n\n        node.previous = currentPreviousNode;\n        node.next = currentNextNode;\n      }\n    }\n    this.length++;\n    this.createInternalArrayRepresentation();\n  }\n\n  remove(position = 0): void {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    if (position === 0) {\n      // first node\n      this.head = this.head.next;\n\n      if (this.head) {\n        // there is no second node\n        this.head.previous = undefined;\n      } else {\n        // there is no second node\n        this.tail = undefined;\n      }\n    } else if (position === this.length - 1) {\n      // last node\n      this.tail = this.tail.previous;\n      this.tail.next = undefined;\n    } else {\n      // middle node\n      const removedNode = this.getNode(position);\n      removedNode.next.previous = removedNode.previous;\n      removedNode.previous.next = removedNode.next;\n    }\n\n    this.length--;\n    this.createInternalArrayRepresentation();\n  }\n\n  set(position: number, value: T): void {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    const node = this.getNode(position);\n    node.value = value;\n    this.createInternalArrayRepresentation();\n  }\n\n  toArray(): T[] {\n    return this.asArray;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  findAll(fn: any): any[] {\n    let current = this.head;\n    /* tslint:disable-next-line: no-any*/\n    const result: any[] = [];\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result.push({index, value: current.value});\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  // Array methods overriding start\n  push(...args: T[]): number {\n    /* tslint:disable-next-line: no-any*/\n    args.forEach((arg: any) => {\n      this.add(arg);\n    });\n\n    return this.length;\n  }\n\n  pop(): T {\n    if (this.length === 0) {\n      return undefined;\n    }\n    const last = this.tail;\n    this.remove(this.length - 1);\n\n    return last.value;\n  }\n\n  unshift(...args: T[]): number {\n    args.reverse();\n    /* tslint:disable-next-line: no-any*/\n    args.forEach((arg: any) => {\n      this.add(arg, 0);\n    });\n\n    return this.length;\n  }\n\n  shift(): T {\n    if (this.length === 0) {\n      return undefined;\n    }\n    const lastItem = this.head.value;\n    this.remove();\n\n    return lastItem;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  forEach(fn: any): void {\n    let current = this.head;\n    for (let index = 0; index < this.length; index++) {\n      fn(current.value, index);\n      current = current.next;\n    }\n  }\n\n  indexOf(value: T): number {\n    let current = this.head;\n    let position = 0;\n\n    for (let index = 0; index < this.length; index++) {\n      if (current.value === value) {\n        position = index;\n        break;\n      }\n      current = current.next;\n    }\n\n    return position;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  some(fn: any): boolean {\n    let current = this.head;\n    let result = false;\n    while (current && !result) {\n      if (fn(current.value)) {\n        result = true;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  every(fn: any): boolean {\n    let current = this.head;\n    let result = true;\n    while (current && result) {\n      if (!fn(current.value)) {\n        result = false;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  toString(): string {\n    return '[Linked List]';\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  find(fn: any): T {\n    let current = this.head;\n    let result: T;\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result = current.value;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  findIndex(fn: any): number {\n    let current = this.head;\n    let result: number;\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result = index;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  protected getNode(position: number): any {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    let current = this.head;\n\n    for (let index = 0; index < position; index++) {\n      current = current.next;\n    }\n\n    return current;\n  }\n\n  protected createInternalArrayRepresentation(): void {\n    /* tslint:disable-next-line: no-any*/\n    const outArray: any[] = [];\n    let current = this.head;\n\n    while (current) {\n      outArray.push(current.value);\n      current = current.next;\n    }\n    this.asArray = outArray;\n  }\n\n  // Array methods overriding END\n}\n","/*tslint:disable:no-invalid-this */\n/* tslint:disable-next-line: no-any */\nexport function OnChange(defaultValue?: any): any {\n  const sufix = 'Change';\n\n  /* tslint:disable-next-line: no-any */\n  return function OnChangeHandler(target: any, propertyKey: string): void {\n    const _key = ` __${propertyKey}Value`;\n    Object.defineProperty(target, propertyKey, {\n      /* tslint:disable-next-line: no-any */\n      get(): any {\n        return this[_key];\n      },\n      /* tslint:disable-next-line: no-any */\n      set(value: any): void {\n        const prevValue = this[_key];\n        this[_key] = value;\n        if (prevValue !== value && this[propertyKey + sufix]) {\n          this[propertyKey + sufix].emit(value);\n        }\n      }\n    });\n  };\n}\n/* tslint:enable */\n","import { window } from './facade/browser';\n\nexport class Utils {\n  /* tslint:disable-next-line: no-any */\n  static reflow(element: any): void {\n    /* tslint:disable-next-line: no-any */\n    ((bs: any): void => bs)(element.offsetHeight);\n  }\n\n  // source: https://github.com/jquery/jquery/blob/master/src/css/var/getStyles.js\n  /* tslint:disable-next-line: no-any */\n  static getStyles(elem: any): any {\n    // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n    // IE throws on elements created in popups\n    // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n    let view = elem.ownerDocument.defaultView;\n\n    if (!view || !view.opener) {\n      view = window;\n    }\n\n    return view.getComputedStyle(elem);\n  }\n}\n","import { isDevMode } from '@angular/core';\nconst _messagesHash: { [key: string]: boolean } = {};\nconst _hideMsg = typeof console === 'undefined' || !('warn' in console);\n\nexport function warnOnce(msg: string): void {\n  if (!isDevMode() || _hideMsg || msg in _messagesHash) {\n    return;\n  }\n\n  _messagesHash[msg] = true;\n  /*tslint:disable-next-line*/\n  console.warn(msg);\n}\n"],"names":["document","window","isDevMode"],"mappings":"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"}