ngx-bootstrap 3.2.0 → 3.3.0

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

@@ -1,294 +1,1195 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core')) :
-    typeof define === 'function' && define.amd ? define('ngx-bootstrap/positioning', ['exports', '@angular/core'], factory) :
-    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].positioning = {}),global.ng.core));
-}(this, (function (exports,core) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/positioning', ['exports', '@angular/core', 'rxjs'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].positioning = {}),global.ng.core,global.rxjs));
+}(this, (function (exports,core,rxjs) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Get CSS computed property of the given element
+     * @param {?} element
+     * @param {?=} property
+     * @return {?}
+     */
+    function getStyleComputedProperty(element, property) {
+        if (element.nodeType !== 1) {
+            return [];
+        }
+        // NOTE: 1 DOM access here
+        var /** @type {?} */ window = element.ownerDocument.defaultView;
+        var /** @type {?} */ css = window.getComputedStyle(element, null);
+        return property ? css[property] : css;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Returns the parentNode or the host of the element
+     * @param {?} element
+     * @return {?}
+     */
+    function getParentNode(element) {
+        if (element.nodeName === 'HTML') {
+            return element;
+        }
+        return element.parentNode || element.host;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function getScrollParent(element) {
+        // Return body, `getScroll` will take care to get the correct `scrollTop` from it
+        if (!element) {
+            return document.body;
+        }
+        switch (element.nodeName) {
+            case 'HTML':
+            case 'BODY':
+                return element.ownerDocument.body;
+            case '#document':
+                return element.body;
+            default:
+        }
+        // Firefox want us to check `-x` and `-y` variations as well
+        var _a = getStyleComputedProperty(element), overflow = _a.overflow, overflowX = _a.overflowX, overflowY = _a.overflowY;
+        if (/(auto|scroll|overlay)/.test(String(overflow) + String(overflowY) + String(overflowX))) {
+            return element;
+        }
+        return getScrollParent(getParentNode(element));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ isIE11 = isBrowser && !!(((window)).MSInputMethodContext && ((document)).documentMode);
+    var /** @type {?} */ isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
+    /**
+     * @param {?=} version
+     * @return {?}
+     */
+    function isIE(version) {
+        if (version === 11) {
+            return isIE11;
+        }
+        if (version === 10) {
+            return isIE10;
+        }
+        return isIE11 || isIE10;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function getOffsetParent(element) {
+        if (!element) {
+            return document.documentElement;
+        }
+        var /** @type {?} */ noOffsetParent = isIE(10) ? document.body : null;
+        // NOTE: 1 DOM access here
+        var /** @type {?} */ offsetParent = element.offsetParent || null;
+        // Skip hidden elements which don't have an offsetParent
+        var /** @type {?} */ sibling;
+        while (offsetParent === noOffsetParent && element.nextElementSibling) {
+            sibling = element.nextElementSibling;
+            offsetParent = sibling.offsetParent;
+        }
+        var /** @type {?} */ nodeName = offsetParent && offsetParent.nodeName;
+        if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
+            return sibling ? sibling.ownerDocument.documentElement : document.documentElement;
+        }
+        // .offsetParent will return the closest TH, TD or TABLE in case
+        // no offsetParent is present, I hate this job...
+        if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 &&
+            getStyleComputedProperty(offsetParent, 'position') === 'static') {
+            return getOffsetParent(offsetParent);
+        }
+        return offsetParent;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function isOffsetContainer(element) {
+        var nodeName = element.nodeName;
+        if (nodeName === 'BODY') {
+            return false;
+        }
+        return (nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Finds the root node (document, shadowDOM root) of the given element
+     * @param {?} node
+     * @return {?}
+     */
+    function getRoot(node) {
+        if (node.parentNode !== null) {
+            return getRoot(node.parentNode);
+        }
+        return node;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element1
+     * @param {?} element2
+     * @return {?}
+     */
+    function findCommonOffsetParent(element1, element2) {
+        // This check is needed to avoid errors in case one of the elements isn't defined for any reason
+        if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
+            return document.documentElement;
+        }
+        // Here we make sure to give as "start" the element that comes first in the DOM
+        /* tslint:disable-next-line: no-bitwise */
+        var /** @type {?} */ order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
+        var /** @type {?} */ start = order ? element1 : element2;
+        var /** @type {?} */ end = order ? element2 : element1;
+        // Get common ancestor container
+        var /** @type {?} */ range = document.createRange();
+        range.setStart(start, 0);
+        range.setEnd(end, 0);
+        var commonAncestorContainer = range.commonAncestorContainer;
+        // Both nodes are inside #document
+        if ((element1 !== commonAncestorContainer &&
+            element2 !== commonAncestorContainer) ||
+            start.contains(end)) {
+            if (isOffsetContainer(commonAncestorContainer)) {
+                return commonAncestorContainer;
+            }
+            return getOffsetParent(commonAncestorContainer);
+        }
+        // one of the nodes is inside shadowDOM, find which one
+        var /** @type {?} */ element1root = getRoot(element1);
+        if (element1root.host) {
+            return findCommonOffsetParent(element1root.host, element2);
+        }
+        else {
+            return findCommonOffsetParent(element1, getRoot(element2).host);
+        }
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Helper to detect borders of a given element
+     */
+    /**
+     * @param {?} styles
+     * @param {?} axis
+     * @return {?}
+     */
+    function getBordersSize(styles, axis) {
+        var /** @type {?} */ sideA = axis === 'x' ? 'Left' : 'Top';
+        var /** @type {?} */ sideB = sideA === 'Left' ? 'Right' : 'Bottom';
+        return (parseFloat(styles["border" + sideA + "Width"]) +
+            parseFloat(styles["border" + sideB + "Width"]));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} axis
+     * @param {?} body
+     * @param {?} html
+     * @param {?} computedStyle
+     * @return {?}
+     */
+    function getSize(axis, body, html, computedStyle) {
+        return Math.max(body["offset" + axis], body["scroll" + axis], html["client" + axis], html["offset" + axis], html["scroll" + axis], isIE(10)
+            ? (parseInt(html["offset" + axis], 10) +
+                parseInt(computedStyle["margin" + (axis === 'Height' ? 'Top' : 'Left')], 10) +
+                parseInt(computedStyle["margin" + (axis === 'Height' ? 'Bottom' : 'Right')], 10))
+            : 0);
+    }
+    /**
+     * @param {?} document
+     * @return {?}
+     */
+    function getWindowSizes(document) {
+        var /** @type {?} */ body = document.body;
+        var /** @type {?} */ html = document.documentElement;
+        var /** @type {?} */ computedStyle = isIE(10) && getComputedStyle(html);
+        return {
+            height: getSize('Height', body, html, computedStyle),
+            width: getSize('Width', body, html, computedStyle)
+        };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Gets the scroll value of the given element in the given side (top and left)
+     * @param {?} element
+     * @param {?=} side
+     * @return {?}
+     */
+    function getScroll(element, side) {
+        if (side === void 0) {
+            side = 'top';
+        }
+        var /** @type {?} */ upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
+        var /** @type {?} */ nodeName = element.nodeName;
+        if (nodeName === 'BODY' || nodeName === 'HTML') {
+            var /** @type {?} */ html = element.ownerDocument.documentElement;
+            var /** @type {?} */ scrollingElement = element.ownerDocument.scrollingElement || html;
+            return scrollingElement[upperSide];
+        }
+        return element[upperSide];
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} offsets
+     * @return {?}
+     */
+    function getClientRect(offsets) {
+        return __assign({}, offsets, { right: offsets.left + offsets.width, bottom: offsets.top + offsets.height });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function getBoundingClientRect(element) {
+        var /** @type {?} */ rect = {};
+        // IE10 10 FIX: Please, don't ask, the element isn't
+        // considered in DOM in some circumstances...
+        // This isn't reproducible in IE10 compatibility mode of IE11
+        try {
+            if (isIE(10)) {
+                rect = element.getBoundingClientRect();
+                var /** @type {?} */ scrollTop = getScroll(element, 'top');
+                var /** @type {?} */ scrollLeft = getScroll(element, 'left');
+                rect.top += scrollTop;
+                rect.left += scrollLeft;
+                rect.bottom += scrollTop;
+                rect.right += scrollLeft;
+            }
+            else {
+                rect = element.getBoundingClientRect();
+            }
+        }
+        catch (e) {
+            return undefined;
+        }
+        var /** @type {?} */ result = {
+            left: rect.left,
+            top: rect.top,
+            width: rect.right - rect.left,
+            height: rect.bottom - rect.top
+        };
+        // subtract scrollbar size from sizes
+        var /** @type {?} */ sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
+        var /** @type {?} */ width = sizes.width || element.clientWidth || result.right - result.left;
+        var /** @type {?} */ height = sizes.height || element.clientHeight || result.bottom - result.top;
+        var /** @type {?} */ horizScrollbar = element.offsetWidth - width;
+        var /** @type {?} */ vertScrollbar = element.offsetHeight - height;
+        // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
+        // we make this check conditional for performance reasons
+        if (horizScrollbar || vertScrollbar) {
+            var /** @type {?} */ styles = getStyleComputedProperty(element);
+            horizScrollbar -= getBordersSize(styles, 'x');
+            vertScrollbar -= getBordersSize(styles, 'y');
+            result.width -= horizScrollbar;
+            result.height -= vertScrollbar;
+        }
+        return getClientRect(result);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} rect
+     * @param {?} element
+     * @param {?=} subtract
+     * @return {?}
+     */
+    function includeScroll(rect, element, subtract) {
+        if (subtract === void 0) {
+            subtract = false;
+        }
+        var /** @type {?} */ scrollTop = getScroll(element, 'top');
+        var /** @type {?} */ scrollLeft = getScroll(element, 'left');
+        var /** @type {?} */ modifier = subtract ? -1 : 1;
+        rect.top += scrollTop * modifier;
+        rect.bottom += scrollTop * modifier;
+        rect.left += scrollLeft * modifier;
+        rect.right += scrollLeft * modifier;
+        return rect;
+    }
 
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes} checked by tsc
      */
     /**
-     * @copyright Valor Software
-     * @copyright Angular ng-bootstrap team
+     * @param {?} children
+     * @param {?} parent
+     * @param {?=} fixedPosition
+     * @return {?}
+     */
+    function getOffsetRectRelativeToArbitraryNode(children, parent, fixedPosition) {
+        if (fixedPosition === void 0) {
+            fixedPosition = false;
+        }
+        var /** @type {?} */ isIE10 = isIE(10);
+        var /** @type {?} */ isHTML = parent.nodeName === 'HTML';
+        var /** @type {?} */ childrenRect = getBoundingClientRect(children);
+        var /** @type {?} */ parentRect = getBoundingClientRect(parent);
+        var /** @type {?} */ scrollParent = getScrollParent(children);
+        var /** @type {?} */ styles = getStyleComputedProperty(parent);
+        var /** @type {?} */ borderTopWidth = parseFloat(styles.borderTopWidth);
+        var /** @type {?} */ borderLeftWidth = parseFloat(styles.borderLeftWidth);
+        // In cases where the parent is fixed, we must ignore negative scroll in offset calc
+        if (fixedPosition && isHTML) {
+            parentRect.top = Math.max(parentRect.top, 0);
+            parentRect.left = Math.max(parentRect.left, 0);
+        }
+        var /** @type {?} */ offsets = getClientRect({
+            top: childrenRect.top - parentRect.top - borderTopWidth,
+            left: childrenRect.left - parentRect.left - borderLeftWidth,
+            width: childrenRect.width,
+            height: childrenRect.height
+        });
+        offsets.marginTop = 0;
+        offsets.marginLeft = 0;
+        // Subtract margins of documentElement in case it's being used as parent
+        // we do this only on HTML because it's the only element that behaves
+        // differently when margins are applied to it. The margins are included in
+        // the box of the documentElement, in the other cases not.
+        if (!isIE10 && isHTML) {
+            var /** @type {?} */ marginTop = parseFloat(styles.marginTop);
+            var /** @type {?} */ marginLeft = parseFloat(styles.marginLeft);
+            offsets.top -= borderTopWidth - marginTop;
+            offsets.bottom -= borderTopWidth - marginTop;
+            offsets.left -= borderLeftWidth - marginLeft;
+            offsets.right -= borderLeftWidth - marginLeft;
+            // Attach marginTop and marginLeft because in some circumstances we may need them
+            offsets.marginTop = marginTop;
+            offsets.marginLeft = marginLeft;
+        }
+        if (isIE10 && !fixedPosition
+            ? parent.contains(scrollParent)
+            : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
+            offsets = includeScroll(offsets, parent);
+        }
+        return offsets;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @param {?=} excludeScroll
+     * @return {?}
+     */
+    function getViewportOffsetRectRelativeToArtbitraryNode(element, excludeScroll) {
+        if (excludeScroll === void 0) {
+            excludeScroll = false;
+        }
+        var /** @type {?} */ html = element.ownerDocument.documentElement;
+        var /** @type {?} */ relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
+        var /** @type {?} */ width = Math.max(html.clientWidth, window.innerWidth || 0);
+        var /** @type {?} */ height = Math.max(html.clientHeight, window.innerHeight || 0);
+        var /** @type {?} */ scrollTop = !excludeScroll ? getScroll(html) : 0;
+        var /** @type {?} */ scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
+        var /** @type {?} */ offset = {
+            top: scrollTop - Number(relativeOffset.top) + Number(relativeOffset.marginTop),
+            left: scrollLeft - Number(relativeOffset.left) + Number(relativeOffset.marginLeft),
+            width: width,
+            height: height
+        };
+        return getClientRect(offset);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function isFixed(element) {
+        var /** @type {?} */ nodeName = element.nodeName;
+        if (nodeName === 'BODY' || nodeName === 'HTML') {
+            return false;
+        }
+        if (getStyleComputedProperty(element, 'position') === 'fixed') {
+            return true;
+        }
+        return isFixed(getParentNode(element));
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function getFixedPositionOffsetParent(element) {
+        // This check is needed to avoid errors in case one of the elements isn't defined for any reason
+        if (!element || !element.parentElement || isIE()) {
+            return document.documentElement;
+        }
+        var /** @type {?} */ el = element.parentElement;
+        while (el && getStyleComputedProperty(el, 'transform') === 'none') {
+            el = el.parentElement;
+        }
+        return el || document.documentElement;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} target
+     * @param {?} host
+     * @param {?=} padding
+     * @param {?=} boundariesElement
+     * @param {?=} fixedPosition
+     * @return {?}
+     */
+    function getBoundaries(target, host, padding, boundariesElement, fixedPosition) {
+        if (padding === void 0) {
+            padding = 0;
+        }
+        if (fixedPosition === void 0) {
+            fixedPosition = false;
+        }
+        // NOTE: 1 DOM access here
+        var /** @type {?} */ boundaries = { top: 0, left: 0 };
+        var /** @type {?} */ offsetParent = fixedPosition ? getFixedPositionOffsetParent(target) : findCommonOffsetParent(target, host);
+        // Handle viewport case
+        if (boundariesElement === 'viewport') {
+            boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
+        }
+        else {
+            // Handle other cases based on DOM element used as boundaries
+            var /** @type {?} */ boundariesNode = void 0;
+            if (boundariesElement === 'scrollParent') {
+                boundariesNode = getScrollParent(getParentNode(host));
+                if (boundariesNode.nodeName === 'BODY') {
+                    boundariesNode = target.ownerDocument.documentElement;
+                }
+            }
+            else if (boundariesElement === 'window') {
+                boundariesNode = target.ownerDocument.documentElement;
+            }
+            else {
+                boundariesNode = boundariesElement;
+            }
+            var /** @type {?} */ offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
+            // In case of HTML, we need a different computation
+            if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
+                var _a = getWindowSizes(target.ownerDocument), height = _a.height, width = _a.width;
+                boundaries.top += offsets.top - offsets.marginTop;
+                boundaries.bottom = Number(height) + Number(offsets.top);
+                boundaries.left += offsets.left - offsets.marginLeft;
+                boundaries.right = Number(width) + Number(offsets.left);
+            }
+            else {
+                // for all the other DOM elements, this one is good
+                boundaries = offsets;
+            }
+        }
+        // Add paddings
+        boundaries.left += padding;
+        boundaries.top += padding;
+        boundaries.right -= padding;
+        boundaries.bottom -= padding;
+        return boundaries;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} __0
+     * @return {?}
+     */
+    function getArea(_a) {
+        var width = _a.width, height = _a.height;
+        return width * height;
+    }
+    /**
+     * @param {?} placement
+     * @param {?} refRect
+     * @param {?} target
+     * @param {?} host
+     * @param {?} boundariesElement
+     * @param {?=} padding
+     * @return {?}
+     */
+    function computeAutoPlacement(placement, refRect, target, host, boundariesElement, padding) {
+        if (padding === void 0) {
+            padding = 0;
+        }
+        if (placement.indexOf('auto') === -1) {
+            return placement;
+        }
+        if (placement.indexOf('auto') !== -1
+            && (placement.indexOf('left') !== -1
+                || placement.indexOf('right') !== -1
+                || placement.indexOf('top') !== -1
+                || placement.indexOf('bottom') !== -1)) {
+            return placement.split(' ')[1] || '';
+        }
+        var /** @type {?} */ boundaries = getBoundaries(target, host, padding, boundariesElement);
+        var /** @type {?} */ rects = {
+            top: {
+                width: boundaries.width,
+                height: refRect.top - boundaries.top
+            },
+            right: {
+                width: boundaries.right - refRect.right,
+                height: boundaries.height
+            },
+            bottom: {
+                width: boundaries.width,
+                height: boundaries.bottom - refRect.bottom
+            },
+            left: {
+                width: refRect.left - boundaries.left,
+                height: boundaries.height
+            }
+        };
+        var /** @type {?} */ sortedAreas = Object.keys(rects)
+            .map(function (key) {
+            return (__assign({ key: key }, rects[key], { area: getArea(rects[key]) }));
+        })
+            .sort(function (a, b) { return b.area - a.area; });
+        var /** @type {?} */ filteredAreas = sortedAreas.filter(function (_a) {
+            var width = _a.width, height = _a.height;
+            return width >= target.clientWidth && height >= target.clientHeight;
+        });
+        var /** @type {?} */ computedPlacement = filteredAreas.length > 0
+            ? filteredAreas[0].key
+            : sortedAreas[0].key;
+        var /** @type {?} */ variation = placement.split(' ')[1];
+        target.className = target.className.replace(/auto/g, computedPlacement);
+        return computedPlacement + (variation ? "-" + variation : '');
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function getOffsets(data) {
+        return {
+            width: data.offsets.target.width,
+            height: data.offsets.target.height,
+            left: Math.floor(data.offsets.target.left),
+            top: Math.round(data.offsets.target.top),
+            bottom: Math.round(data.offsets.target.bottom),
+            right: Math.floor(data.offsets.target.right)
+        };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Get the opposite placement of the given one
+     * @param {?} placement
+     * @return {?}
+     */
+    function getOppositePlacement(placement) {
+        var /** @type {?} */ hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
+        return placement.replace(/left|right|bottom|top/g, function (matched) { return hash[matched]; });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Get the opposite placement variation of the given one
+     * @param {?} variation
+     * @return {?}
+     */
+    function getOppositeVariation(variation) {
+        if (variation === 'right') {
+            return 'left';
+        }
+        else if (variation === 'left') {
+            return 'right';
+        }
+        return variation;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Get the outer sizes of the given element (offset size + margins)
+     * @param {?} element
+     * @return {?}
+     */
+    function getOuterSizes(element) {
+        var /** @type {?} */ window = element.ownerDocument.defaultView;
+        var /** @type {?} */ styles = window.getComputedStyle(element);
+        var /** @type {?} */ x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
+        var /** @type {?} */ y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
+        return {
+            width: Number(element.offsetWidth) + y,
+            height: Number(element.offsetHeight) + x
+        };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} target
+     * @param {?} host
+     * @param {?=} fixedPosition
+     * @return {?}
+     */
+    function getReferenceOffsets(target, host, fixedPosition) {
+        if (fixedPosition === void 0) {
+            fixedPosition = null;
+        }
+        var /** @type {?} */ commonOffsetParent = fixedPosition
+            ? getFixedPositionOffsetParent(target)
+            : findCommonOffsetParent(target, host);
+        return getOffsetRectRelativeToArbitraryNode(host, commonOffsetParent, fixedPosition);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} target
+     * @param {?} hostOffsets
+     * @param {?} position
+     * @return {?}
+     */
+    function getTargetOffsets(target, hostOffsets, position) {
+        var /** @type {?} */ placement = position.split(' ')[0];
+        // Get target node sizes
+        var /** @type {?} */ targetRect = getOuterSizes(target);
+        // Add position, width and height to our offsets object
+        var /** @type {?} */ targetOffsets = {
+            width: targetRect.width,
+            height: targetRect.height
+        };
+        // depending by the target placement we have to compute its offsets slightly differently
+        var /** @type {?} */ isHoriz = ['right', 'left'].indexOf(placement) !== -1;
+        var /** @type {?} */ mainSide = isHoriz ? 'top' : 'left';
+        var /** @type {?} */ secondarySide = isHoriz ? 'left' : 'top';
+        var /** @type {?} */ measurement = isHoriz ? 'height' : 'width';
+        var /** @type {?} */ secondaryMeasurement = !isHoriz ? 'height' : 'width';
+        targetOffsets[mainSide] =
+            hostOffsets[mainSide] +
+                hostOffsets[measurement] / 2 -
+                targetRect[measurement] / 2;
+        targetOffsets[secondarySide] = placement === secondarySide
+            ? hostOffsets[secondarySide] - targetRect[secondaryMeasurement]
+            : hostOffsets[getOppositePlacement(secondarySide)];
+        return targetOffsets;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * Tells if a given input is a number
+     * @param {?} n
+     * @return {?}
+     */
+    function isNumeric(n) {
+        return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @param {?=} renderer
+     * @return {?}
+     */
+    function setAllStyles$$1(data, renderer) {
+        var /** @type {?} */ target = data.instance.target;
+        var /** @type {?} */ offsets = getOffsets(data);
+        setStyles(target, {
+            'will-change': 'transform',
+            top: '0px',
+            left: '0px',
+            transform: "translate3d(" + offsets.left + "px, " + offsets.top + "px, 0px)"
+        }, renderer);
+        if (data.instance.arrow) {
+            setStyles(data.instance.arrow, data.offsets.arrow, renderer);
+        }
+        if (data.placementAuto) {
+            if (renderer) {
+                renderer.setAttribute(target, 'class', target.className.replace(/bs-popover-auto/g, "bs-popover-" + data.placement));
+                renderer.setAttribute(target, 'class', target.className.replace(/bs-tooltip-auto/g, "bs-tooltip-" + data.placement));
+                renderer.setAttribute(target, 'class', target.className.replace(/\sauto/g, "s" + data.placement));
+                if (target.className.match(/popover/g)) {
+                    renderer.addClass(target, 'popover-auto');
+                }
+                if (target.className.match(/tooltip/g)) {
+                    renderer.addClass(target, 'tooltip-auto');
+                }
+            }
+            else {
+                target.className = target.className.replace(/bs-popover-auto/g, "bs-popover-" + data.placement);
+                target.className = target.className.replace(/bs-tooltip-auto/g, "bs-tooltip-" + data.placement);
+                target.className = target.className.replace(/\sauto/g, "s" + data.placement);
+                if (target.className.match(/popover/g)) {
+                    target.classList.add('popover-auto');
+                }
+                if (target.className.match(/tooltip/g)) {
+                    target.classList.add('tooltip-auto');
+                }
+            }
+        }
+        if (renderer) {
+            renderer.setAttribute(target, 'class', target.className.replace(/left|right|top|bottom/g, "" + data.placement));
+        }
+        else {
+            target.className = target.className.replace(/left|right|top|bottom/g, "" + data.placement);
+        }
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} element
+     * @param {?} styles
+     * @param {?=} renderer
+     * @return {?}
+     */
+    function setStyles(element, styles, renderer) {
+        Object.keys(styles).forEach(function (prop) {
+            var /** @type {?} */ unit = '';
+            // add unit if the value is numeric and is one of the following
+            if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 &&
+                isNumeric(styles[prop])) {
+                unit = 'px';
+            }
+            if (renderer) {
+                renderer.setStyle(element, prop, "" + String(styles[prop]) + unit);
+                return;
+            }
+            element.style[prop] = String(styles[prop]) + unit;
+        });
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function arrow(data) {
+        var /** @type {?} */ targetOffsets = data.offsets.target;
+        // if arrowElement is a string, suppose it's a CSS selector
+        var /** @type {?} */ arrowElement = data.instance.target.querySelector('.arrow');
+        // if arrowElement is not found, don't run the modifier
+        if (!arrowElement) {
+            return data;
+        }
+        var /** @type {?} */ isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
+        var /** @type {?} */ len = isVertical ? 'height' : 'width';
+        var /** @type {?} */ sideCapitalized = isVertical ? 'Top' : 'Left';
+        var /** @type {?} */ side = sideCapitalized.toLowerCase();
+        var /** @type {?} */ altSide = isVertical ? 'left' : 'top';
+        var /** @type {?} */ opSide = isVertical ? 'bottom' : 'right';
+        var /** @type {?} */ arrowElementSize = getOuterSizes(arrowElement)[len];
+        // top/left side
+        if (data.offsets.host[opSide] - arrowElementSize < targetOffsets[side]) {
+            targetOffsets[side] -=
+                targetOffsets[side] - (data.offsets.host[opSide] - arrowElementSize);
+        }
+        // bottom/right side
+        if (Number(data.offsets.host[side]) + Number(arrowElementSize) > targetOffsets[opSide]) {
+            targetOffsets[side] +=
+                Number(data.offsets.host[side]) + Number(arrowElementSize) - Number(targetOffsets[opSide]);
+        }
+        targetOffsets = getClientRect(targetOffsets);
+        // compute center of the target
+        var /** @type {?} */ center = Number(data.offsets.host[side]) + Number(data.offsets.host[len] / 2 - arrowElementSize / 2);
+        // Compute the sideValue using the updated target offsets
+        // take target margin in account because we don't have this info available
+        var /** @type {?} */ css = getStyleComputedProperty(data.instance.target);
+        var /** @type {?} */ targetMarginSide = parseFloat(css["margin" + sideCapitalized]);
+        var /** @type {?} */ targetBorderSide = parseFloat(css["border" + sideCapitalized + "Width"]);
+        var /** @type {?} */ sideValue = center - targetOffsets[side] - targetMarginSide - targetBorderSide;
+        // prevent arrowElement from being placed not contiguously to its target
+        sideValue = Math.max(Math.min(targetOffsets[len] - arrowElementSize, sideValue), 0);
+        data.offsets.arrow = (_a = {},
+            _a[side] = Math.round(sideValue),
+            _a[altSide] = '' // make sure to unset any eventual altSide value from the DOM node
+            ,
+                _a);
+        data.instance.arrow = arrowElement;
+        return data;
+        var _a;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function flip(data) {
+        data.offsets.target = getClientRect(data.offsets.target);
+        var /** @type {?} */ boundaries = getBoundaries(data.instance.target, data.instance.host, 0, // padding
+        'viewport', false // positionFixed
+        );
+        var /** @type {?} */ placement = data.placement.split(' ')[0];
+        var /** @type {?} */ variation = data.placement.split(' ')[1] || '';
+        var /** @type {?} */ adaptivePosition = variation
+            ? getOppositePlacement(placement)
+            : computeAutoPlacement('auto', data.offsets.host, data.instance.target, data.instance.host, 'viewport', 0);
+        var /** @type {?} */ flipOrder = [placement, adaptivePosition];
+        /* tslint:disable-next-line: cyclomatic-complexity */
+        flipOrder.forEach(function (step, index) {
+            if (placement !== step || flipOrder.length === index + 1) {
+                return data;
+            }
+            placement = data.placement.split(' ')[0];
+            // using floor because the host offsets may contain decimals we are not going to consider here
+            var /** @type {?} */ overlapsRef = (placement === 'left' &&
+                Math.floor(data.offsets.target.right) > Math.floor(data.offsets.host.left)) ||
+                (placement === 'right' &&
+                    Math.floor(data.offsets.target.left) < Math.floor(data.offsets.host.right)) ||
+                (placement === 'top' &&
+                    Math.floor(data.offsets.target.bottom) > Math.floor(data.offsets.host.top)) ||
+                (placement === 'bottom' &&
+                    Math.floor(data.offsets.target.top) < Math.floor(data.offsets.host.bottom));
+            var /** @type {?} */ overflowsLeft = Math.floor(data.offsets.target.left) < Math.floor(boundaries.left);
+            var /** @type {?} */ overflowsRight = Math.floor(data.offsets.target.right) > Math.floor(boundaries.right);
+            var /** @type {?} */ overflowsTop = Math.floor(data.offsets.target.top) < Math.floor(boundaries.top);
+            var /** @type {?} */ overflowsBottom = Math.floor(data.offsets.target.bottom) > Math.floor(boundaries.bottom);
+            var /** @type {?} */ overflowsBoundaries = (placement === 'left' && overflowsLeft) ||
+                (placement === 'right' && overflowsRight) ||
+                (placement === 'top' && overflowsTop) ||
+                (placement === 'bottom' && overflowsBottom);
+            // flip the variation if required
+            var /** @type {?} */ isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
+            var /** @type {?} */ flippedVariation = ((isVertical && variation === 'left' && overflowsLeft) ||
+                (isVertical && variation === 'right' && overflowsRight) ||
+                (!isVertical && variation === 'left' && overflowsTop) ||
+                (!isVertical && variation === 'right' && overflowsBottom));
+            if (overlapsRef || overflowsBoundaries || flippedVariation) {
+                // this boolean to detect any flip loop
+                if (overlapsRef || overflowsBoundaries) {
+                    placement = flipOrder[index + 1];
+                }
+                if (flippedVariation) {
+                    variation = getOppositeVariation(variation);
+                }
+                data.placement = placement + (variation ? " " + variation : '');
+                data.offsets.target = __assign({}, data.offsets.target, getTargetOffsets(data.instance.target, data.offsets.host, data.placement));
+            }
+        });
+        return data;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} targetElement
+     * @param {?} hostElement
+     * @param {?} position
+     * @return {?}
+     */
+    function initData(targetElement, hostElement, position) {
+        var /** @type {?} */ hostElPosition = getReferenceOffsets(targetElement, hostElement);
+        var /** @type {?} */ targetOffset = getTargetOffsets(targetElement, hostElPosition, position);
+        var /** @type {?} */ placement = computeAutoPlacement(position, hostElPosition, targetElement, hostElement, 'viewport', 0);
+        var /** @type {?} */ placementAuto = position.indexOf('auto') !== -1;
+        return {
+            instance: {
+                target: targetElement,
+                host: hostElement,
+                arrow: null
+            },
+            offsets: {
+                target: targetOffset,
+                host: hostElPosition,
+                arrow: null
+            },
+            positionFixed: false,
+            placement: placement,
+            placementAuto: placementAuto
+        };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function preventOverflow(data) {
+        // NOTE: DOM access here
+        // resets the targetOffsets's position so that the document size can be calculated excluding
+        // the size of the targetOffsets element itself
+        var /** @type {?} */ transformProp = 'transform';
+        var /** @type {?} */ targetStyles = data.instance.target.style; // assignment to help minification
+        var top = targetStyles.top, left = targetStyles.left, _a = transformProp, transform = targetStyles[_a];
+        targetStyles.top = '';
+        targetStyles.left = '';
+        targetStyles[transformProp] = '';
+        var /** @type {?} */ boundaries = getBoundaries(data.instance.target, data.instance.host, 0, // padding
+        'scrollParent', false // positionFixed
+        );
+        // NOTE: DOM access here
+        // restores the original style properties after the offsets have been computed
+        targetStyles.top = top;
+        targetStyles.left = left;
+        targetStyles[transformProp] = transform;
+        var /** @type {?} */ order = ['left', 'right', 'top', 'bottom'];
+        var /** @type {?} */ check = {
+            primary: /**
+             * @param {?} placement
+             * @return {?}
+             */ function (placement) {
+                var /** @type {?} */ value = data.offsets.target[placement];
+                if (data.offsets.target[placement] < boundaries[placement] &&
+                    !false // options.escapeWithReference
+                ) {
+                    value = Math.max(data.offsets.target[placement], boundaries[placement]);
+                }
+                return _a = {}, _a[placement] = value, _a;
+                var _a;
+            },
+            secondary: /**
+             * @param {?} placement
+             * @return {?}
+             */ function (placement) {
+                var /** @type {?} */ mainSide = placement === 'right' ? 'left' : 'top';
+                var /** @type {?} */ value = data.offsets.target[mainSide];
+                if (data.offsets.target[placement] > boundaries[placement] &&
+                    !false // escapeWithReference
+                ) {
+                    value = Math.min(data.offsets.target[mainSide], boundaries[placement] -
+                        (placement === 'right' ? data.offsets.target.width : data.offsets.target.height));
+                }
+                return _a = {}, _a[mainSide] = value, _a;
+                var _a;
+            }
+        };
+        var /** @type {?} */ side;
+        order.forEach(function (placement) {
+            side = ['left', 'top']
+                .indexOf(placement) !== -1
+                ? 'primary'
+                : 'secondary';
+            data.offsets.target = __assign({}, data.offsets.target, check[side](placement));
+        });
+        return data;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function shift(data) {
+        var /** @type {?} */ placement = data.placement;
+        var /** @type {?} */ basePlacement = placement.split(' ')[0];
+        var /** @type {?} */ shiftvariation = placement.split(' ')[1];
+        if (shiftvariation) {
+            var _a = data.offsets, host = _a.host, target = _a.target;
+            var /** @type {?} */ isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
+            var /** @type {?} */ side = isVertical ? 'left' : 'top';
+            var /** @type {?} */ measurement = isVertical ? 'width' : 'height';
+            var /** @type {?} */ shiftOffsets = {
+                left: (_b = {}, _b[side] = host[side], _b),
+                right: (_c = {},
+                    _c[side] = host[side] + host[measurement] - host[measurement],
+                    _c)
+            };
+            data.offsets.target = __assign({}, target, shiftOffsets[shiftvariation]);
+        }
+        return data;
+        var _b, _c;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
      */
     var Positioning = (function () {
         function Positioning() {
         }
         /**
-         * @param {?} element
+         * @param {?} hostElement
+         * @param {?} targetElement
          * @param {?=} round
          * @return {?}
          */
         Positioning.prototype.position = /**
-         * @param {?} element
+         * @param {?} hostElement
+         * @param {?} targetElement
          * @param {?=} round
          * @return {?}
          */
-            function (element, round) {
+            function (hostElement, targetElement, round) {
                 if (round === void 0) {
                     round = true;
                 }
-                var /** @type {?} */ elPosition;
-                var /** @type {?} */ parentOffset = {
-                    width: 0,
-                    height: 0,
-                    top: 0,
-                    bottom: 0,
-                    left: 0,
-                    right: 0
-                };
-                if (this.getStyle(element, 'position') === 'fixed') {
-                    var /** @type {?} */ bcRect = element.getBoundingClientRect();
-                    elPosition = {
-                        width: bcRect.width,
-                        height: bcRect.height,
-                        top: bcRect.top,
-                        bottom: bcRect.bottom,
-                        left: bcRect.left,
-                        right: bcRect.right
-                    };
-                }
-                else {
-                    var /** @type {?} */ offsetParentEl = this.offsetParent(element);
-                    elPosition = this.offset(element, false);
-                    if (offsetParentEl !== document.documentElement) {
-                        parentOffset = this.offset(offsetParentEl, false);
-                    }
-                    parentOffset.top += offsetParentEl.clientTop;
-                    parentOffset.left += offsetParentEl.clientLeft;
-                }
-                elPosition.top -= parentOffset.top;
-                elPosition.bottom -= parentOffset.top;
-                elPosition.left -= parentOffset.left;
-                elPosition.right -= parentOffset.left;
-                if (round) {
-                    elPosition.top = Math.round(elPosition.top);
-                    elPosition.bottom = Math.round(elPosition.bottom);
-                    elPosition.left = Math.round(elPosition.left);
-                    elPosition.right = Math.round(elPosition.right);
-                }
-                return elPosition;
+                return this.offset(hostElement, targetElement, false);
             };
         /**
-         * @param {?} element
+         * @param {?} hostElement
+         * @param {?} targetElement
          * @param {?=} round
          * @return {?}
          */
         Positioning.prototype.offset = /**
-         * @param {?} element
+         * @param {?} hostElement
+         * @param {?} targetElement
          * @param {?=} round
          * @return {?}
          */
-            function (element, round) {
+            function (hostElement, targetElement, round) {
                 if (round === void 0) {
                     round = true;
                 }
-                var /** @type {?} */ elBcr = element.getBoundingClientRect();
-                var /** @type {?} */ viewportOffset = {
-                    top: window.pageYOffset - document.documentElement.clientTop,
-                    left: window.pageXOffset - document.documentElement.clientLeft
-                };
-                var /** @type {?} */ elOffset = {
-                    height: elBcr.height || element.offsetHeight,
-                    width: elBcr.width || element.offsetWidth,
-                    top: elBcr.top + viewportOffset.top,
-                    bottom: elBcr.bottom + viewportOffset.top,
-                    left: elBcr.left + viewportOffset.left,
-                    right: elBcr.right + viewportOffset.left
-                };
-                if (round) {
-                    elOffset.height = Math.round(elOffset.height);
-                    elOffset.width = Math.round(elOffset.width);
-                    elOffset.top = Math.round(elOffset.top);
-                    elOffset.bottom = Math.round(elOffset.bottom);
-                    elOffset.left = Math.round(elOffset.left);
-                    elOffset.right = Math.round(elOffset.right);
-                }
-                return elOffset;
+                return getReferenceOffsets(targetElement, hostElement);
             };
         /**
          * @param {?} hostElement
          * @param {?} targetElement
-         * @param {?} placement
+         * @param {?} position
          * @param {?=} appendToBody
          * @return {?}
          */
         Positioning.prototype.positionElements = /**
          * @param {?} hostElement
          * @param {?} targetElement
-         * @param {?} placement
+         * @param {?} position
          * @param {?=} appendToBody
          * @return {?}
          */
-            function (hostElement, targetElement, placement, appendToBody) {
-                var /** @type {?} */ hostElPosition = appendToBody
-                    ? this.offset(hostElement, false)
-                    : this.position(hostElement, false);
-                var /** @type {?} */ targetElStyles = this.getAllStyles(targetElement);
-                var /** @type {?} */ targetElBCR = targetElement.getBoundingClientRect();
-                var /** @type {?} */ placementPrimary = placement.split(' ')[0] || 'top';
-                var /** @type {?} */ placementSecondary = placement.split(' ')[1] || 'center';
-                var /** @type {?} */ targetElPosition = {
-                    height: targetElBCR.height || targetElement.offsetHeight,
-                    width: targetElBCR.width || targetElement.offsetWidth,
-                    top: 0,
-                    bottom: targetElBCR.height || targetElement.offsetHeight,
-                    left: 0,
-                    right: targetElBCR.width || targetElement.offsetWidth
-                };
-                var /** @type {?} */ shiftHeight = {
-                    top: hostElPosition.top,
-                    center: hostElPosition.top +
-                        hostElPosition.height / 2 -
-                        targetElPosition.height / 2,
-                    bottom: hostElPosition.top + hostElPosition.height
-                };
-                var /** @type {?} */ shiftWidth = {
-                    left: hostElPosition.left,
-                    center: hostElPosition.left +
-                        hostElPosition.width / 2 -
-                        targetElPosition.width / 2,
-                    right: hostElPosition.left + hostElPosition.width
-                };
-                if (placementPrimary === 'auto') {
-                    var /** @type {?} */ newPlacementPrimary = this.autoPosition(targetElPosition, hostElPosition, targetElement, placementSecondary);
-                    if (!newPlacementPrimary)
-                        newPlacementPrimary = this.autoPosition(targetElPosition, hostElPosition, targetElement);
-                    if (newPlacementPrimary)
-                        placementPrimary = newPlacementPrimary;
-                    targetElement.classList.add(placementPrimary);
-                }
-                switch (placementPrimary) {
-                    case 'top':
-                        targetElPosition.top =
-                            hostElPosition.top -
-                                (targetElPosition.height +
-                                    parseFloat(targetElStyles.marginBottom));
-                        targetElPosition.bottom +=
-                            hostElPosition.top - targetElPosition.height;
-                        targetElPosition.left = shiftWidth[placementSecondary];
-                        targetElPosition.right += shiftWidth[placementSecondary];
-                        break;
-                    case 'bottom':
-                        targetElPosition.top = shiftHeight[placementPrimary];
-                        targetElPosition.bottom += shiftHeight[placementPrimary];
-                        targetElPosition.left = shiftWidth[placementSecondary];
-                        targetElPosition.right += shiftWidth[placementSecondary];
-                        break;
-                    case 'left':
-                        targetElPosition.top = shiftHeight[placementSecondary];
-                        targetElPosition.bottom += shiftHeight[placementSecondary];
-                        targetElPosition.left =
-                            hostElPosition.left -
-                                (targetElPosition.width + parseFloat(targetElStyles.marginRight));
-                        targetElPosition.right +=
-                            hostElPosition.left - targetElPosition.width;
-                        break;
-                    case 'right':
-                        targetElPosition.top = shiftHeight[placementSecondary];
-                        targetElPosition.bottom += shiftHeight[placementSecondary];
-                        targetElPosition.left = shiftWidth[placementPrimary];
-                        targetElPosition.right += shiftWidth[placementPrimary];
-                        break;
-                }
-                targetElPosition.top = Math.round(targetElPosition.top);
-                targetElPosition.bottom = Math.round(targetElPosition.bottom);
-                targetElPosition.left = Math.round(targetElPosition.left);
-                targetElPosition.right = Math.round(targetElPosition.right);
-                return targetElPosition;
-            };
-        /**
-         * @param {?} targetElPosition
-         * @param {?} hostElPosition
-         * @param {?} targetElement
-         * @param {?=} preferredPosition
-         * @return {?}
-         */
-        Positioning.prototype.autoPosition = /**
-         * @param {?} targetElPosition
-         * @param {?} hostElPosition
-         * @param {?} targetElement
-         * @param {?=} preferredPosition
-         * @return {?}
-         */
-            function (targetElPosition, hostElPosition, targetElement, preferredPosition) {
-                if ((!preferredPosition || preferredPosition === 'right') &&
-                    targetElPosition.left + hostElPosition.left - targetElPosition.width <
-                        0) {
-                    return 'right';
-                }
-                else if ((!preferredPosition || preferredPosition === 'top') &&
-                    targetElPosition.bottom +
-                        hostElPosition.bottom +
-                        targetElPosition.height >
-                        window.innerHeight) {
-                    return 'top';
-                }
-                else if ((!preferredPosition || preferredPosition === 'bottom') &&
-                    targetElPosition.top + hostElPosition.top - targetElPosition.height < 0) {
-                    return 'bottom';
-                }
-                else if ((!preferredPosition || preferredPosition === 'left') &&
-                    targetElPosition.right +
-                        hostElPosition.right +
-                        targetElPosition.width >
-                        window.innerWidth) {
-                    return 'left';
-                }
-                return null;
-            };
-        /**
-         * @param {?} element
-         * @return {?}
-         */
-        Positioning.prototype.getAllStyles = /**
-         * @param {?} element
-         * @return {?}
-         */
-            function (element) {
-                return window.getComputedStyle(element);
-            };
-        /**
-         * @param {?} element
-         * @param {?} prop
-         * @return {?}
-         */
-        Positioning.prototype.getStyle = /**
-         * @param {?} element
-         * @param {?} prop
-         * @return {?}
-         */
-            function (element, prop) {
-                return ((this.getAllStyles(element)))[prop];
-            };
-        /**
-         * @param {?} element
-         * @return {?}
-         */
-        Positioning.prototype.isStaticPositioned = /**
-         * @param {?} element
-         * @return {?}
-         */
-            function (element) {
-                return (this.getStyle(element, 'position') || 'static') === 'static';
-            };
-        /**
-         * @param {?} element
-         * @return {?}
-         */
-        Positioning.prototype.offsetParent = /**
-         * @param {?} element
-         * @return {?}
-         */
-            function (element) {
-                var /** @type {?} */ offsetParentEl = (element.offsetParent) || document.documentElement;
-                while (offsetParentEl &&
-                    offsetParentEl !== document.documentElement &&
-                    this.isStaticPositioned(offsetParentEl)) {
-                    offsetParentEl = /** @type {?} */ (offsetParentEl.offsetParent);
-                }
-                return offsetParentEl || document.documentElement;
+            function (hostElement, targetElement, position, appendToBody) {
+                var /** @type {?} */ chainOfModifiers = [flip, shift, preventOverflow, arrow];
+                return chainOfModifiers.reduce(function (modifiedData, modifier) { return modifier(modifiedData); }, initData(targetElement, hostElement, position));
             };
         return Positioning;
     }());
@@ -298,12 +1199,12 @@
      * @param {?} targetElement
      * @param {?} placement
      * @param {?=} appendToBody
+     * @param {?=} renderer
      * @return {?}
      */
-    function positionElements(hostElement, targetElement, placement, appendToBody) {
-        var /** @type {?} */ pos = positionService.positionElements(hostElement, targetElement, placement, appendToBody);
-        targetElement.style.top = pos.top + "px";
-        targetElement.style.left = pos.left + "px";
+    function positionElements(hostElement, targetElement, placement, appendToBody, renderer) {
+        var /** @type {?} */ data = positionService.positionElements(hostElement, targetElement, placement, appendToBody);
+        setAllStyles$$1(data, renderer);
     }
 
     /**
@@ -311,7 +1212,18 @@
      * @suppress {checkTypes} checked by tsc
      */
     var PositioningService = (function () {
-        function PositioningService() {
+        function PositioningService(rendererFactory) {
+            var _this = this;
+            this.update$$ = new rxjs.Subject();
+            this.events$ = rxjs.merge(rxjs.fromEvent(window, 'scroll'), rxjs.fromEvent(window, 'resize'), rxjs.of(0, rxjs.animationFrameScheduler), this.update$$);
+            this.positionElements = new Map();
+            this.events$
+                .subscribe(function () {
+                _this.positionElements
+                    .forEach(function (positionElement) {
+                    positionElements(_getHtmlElement(positionElement.target), _getHtmlElement(positionElement.element), positionElement.attachment, positionElement.appendToBody, rendererFactory.createRenderer(null, null));
+                });
+            });
         }
         /**
          * @param {?} options
@@ -322,12 +1234,40 @@
          * @return {?}
          */
             function (options) {
-                var element = options.element, target = options.target, attachment = options.attachment, appendToBody = options.appendToBody;
-                positionElements(_getHtmlElement(target), _getHtmlElement(element), attachment, appendToBody);
+                this.addPositionElement(options);
+                this.update$$.next();
+            };
+        /**
+         * @param {?} options
+         * @return {?}
+         */
+        PositioningService.prototype.addPositionElement = /**
+         * @param {?} options
+         * @return {?}
+         */
+            function (options) {
+                this.positionElements.set(_getHtmlElement(options.element), options);
+            };
+        /**
+         * @param {?} elRef
+         * @return {?}
+         */
+        PositioningService.prototype.deletePositionElement = /**
+         * @param {?} elRef
+         * @return {?}
+         */
+            function (elRef) {
+                this.positionElements.delete(_getHtmlElement(elRef));
             };
         PositioningService.decorators = [
             { type: core.Injectable }
         ];
+        /** @nocollapse */
+        PositioningService.ctorParameters = function () {
+            return [
+                { type: core.RendererFactory2, },
+            ];
+        };
         return PositioningService;
     }());
     /**
@@ -363,4 +1303,4 @@
 
 })));
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-positioning.umd.js.map","sources":["ng://ngx-bootstrap/positioning/ng-positioning.ts","ng://ngx-bootstrap/positioning/positioning.service.ts"],"sourcesContent":["/**\n * @copyright Valor Software\n * @copyright Angular ng-bootstrap team\n */\n\n// previous version:\n// https://github.com/angular-ui/bootstrap/blob/07c31d0731f7cb068a1932b8e01d2312b796b4ec/src/position/position.js\n// tslint:disable\nexport class Positioning {\n  public position(element: HTMLElement, round = true): ClientRect {\n    let elPosition: ClientRect;\n    let parentOffset: ClientRect = {\n      width: 0,\n      height: 0,\n      top: 0,\n      bottom: 0,\n      left: 0,\n      right: 0\n    };\n\n    if (this.getStyle(element, 'position') === 'fixed') {\n      const bcRect = element.getBoundingClientRect();\n      elPosition = {\n        width: bcRect.width,\n        height: bcRect.height,\n        top: bcRect.top,\n        bottom: bcRect.bottom,\n        left: bcRect.left,\n        right: bcRect.right\n      };\n    } else {\n      const offsetParentEl = this.offsetParent(element);\n\n      elPosition = this.offset(element, false);\n\n      if (offsetParentEl !== document.documentElement) {\n        parentOffset = this.offset(offsetParentEl, false);\n      }\n\n      parentOffset.top += offsetParentEl.clientTop;\n      parentOffset.left += offsetParentEl.clientLeft;\n    }\n\n    elPosition.top -= parentOffset.top;\n    elPosition.bottom -= parentOffset.top;\n    elPosition.left -= parentOffset.left;\n    elPosition.right -= parentOffset.left;\n\n    if (round) {\n      elPosition.top = Math.round(elPosition.top);\n      elPosition.bottom = Math.round(elPosition.bottom);\n      elPosition.left = Math.round(elPosition.left);\n      elPosition.right = Math.round(elPosition.right);\n    }\n\n    return elPosition;\n  }\n\n  public offset(element: HTMLElement, round = true): ClientRect {\n    const elBcr = element.getBoundingClientRect();\n    const viewportOffset = {\n      top: window.pageYOffset - document.documentElement.clientTop,\n      left: window.pageXOffset - document.documentElement.clientLeft\n    };\n\n    let elOffset = {\n      height: elBcr.height || element.offsetHeight,\n      width: elBcr.width || element.offsetWidth,\n      top: elBcr.top + viewportOffset.top,\n      bottom: elBcr.bottom + viewportOffset.top,\n      left: elBcr.left + viewportOffset.left,\n      right: elBcr.right + viewportOffset.left\n    };\n\n    if (round) {\n      elOffset.height = Math.round(elOffset.height);\n      elOffset.width = Math.round(elOffset.width);\n      elOffset.top = Math.round(elOffset.top);\n      elOffset.bottom = Math.round(elOffset.bottom);\n      elOffset.left = Math.round(elOffset.left);\n      elOffset.right = Math.round(elOffset.right);\n    }\n\n    return elOffset;\n  }\n\n  public positionElements(\n    hostElement: HTMLElement,\n    targetElement: HTMLElement,\n    placement: string,\n    appendToBody?: boolean\n  ): ClientRect {\n    const hostElPosition = appendToBody\n      ? this.offset(hostElement, false)\n      : this.position(hostElement, false);\n    const targetElStyles = this.getAllStyles(targetElement);\n    const targetElBCR = targetElement.getBoundingClientRect();\n    let placementPrimary = placement.split(' ')[0] || 'top';\n    const placementSecondary = placement.split(' ')[1] || 'center';\n\n    let targetElPosition: ClientRect = {\n      height: targetElBCR.height || targetElement.offsetHeight,\n      width: targetElBCR.width || targetElement.offsetWidth,\n      top: 0,\n      bottom: targetElBCR.height || targetElement.offsetHeight,\n      left: 0,\n      right: targetElBCR.width || targetElement.offsetWidth\n    };\n\n    const shiftHeight: any = {\n      top: hostElPosition.top,\n      center:\n        hostElPosition.top +\n        hostElPosition.height / 2 -\n        targetElPosition.height / 2,\n      bottom: hostElPosition.top + hostElPosition.height\n    };\n    const shiftWidth: any = {\n      left: hostElPosition.left,\n      center:\n        hostElPosition.left +\n        hostElPosition.width / 2 -\n        targetElPosition.width / 2,\n      right: hostElPosition.left + hostElPosition.width\n    };    \n\n    if (placementPrimary === 'auto') {\n      let newPlacementPrimary = this.autoPosition(\n        targetElPosition,\n        hostElPosition,\n        targetElement,\n        placementSecondary\n      );\n      if (!newPlacementPrimary)\n        newPlacementPrimary = this.autoPosition(\n          targetElPosition,\n          hostElPosition,\n          targetElement\n        );\n      if (newPlacementPrimary) placementPrimary = newPlacementPrimary;\n      targetElement.classList.add(placementPrimary);\n    }\n\n    switch (placementPrimary) {\n      case 'top':\n        targetElPosition.top =\n          hostElPosition.top -\n          (targetElPosition.height +\n            parseFloat(targetElStyles.marginBottom));\n        targetElPosition.bottom +=\n          hostElPosition.top - targetElPosition.height;\n        targetElPosition.left = shiftWidth[placementSecondary];\n        targetElPosition.right += shiftWidth[placementSecondary];\n        break;\n      case 'bottom':\n        targetElPosition.top = shiftHeight[placementPrimary];\n        targetElPosition.bottom += shiftHeight[placementPrimary];\n        targetElPosition.left = shiftWidth[placementSecondary];\n        targetElPosition.right += shiftWidth[placementSecondary];\n        break;\n      case 'left':\n        targetElPosition.top = shiftHeight[placementSecondary];\n        targetElPosition.bottom += shiftHeight[placementSecondary];\n        targetElPosition.left =\n          hostElPosition.left -\n          (targetElPosition.width + parseFloat(targetElStyles.marginRight));\n        targetElPosition.right +=\n          hostElPosition.left - targetElPosition.width;\n        break;\n      case 'right':\n        targetElPosition.top = shiftHeight[placementSecondary];\n        targetElPosition.bottom += shiftHeight[placementSecondary];\n        targetElPosition.left = shiftWidth[placementPrimary];\n        targetElPosition.right += shiftWidth[placementPrimary];\n        break;\n    }\n\n    targetElPosition.top = Math.round(targetElPosition.top);\n    targetElPosition.bottom = Math.round(targetElPosition.bottom);\n    targetElPosition.left = Math.round(targetElPosition.left);\n    targetElPosition.right = Math.round(targetElPosition.right);\n\n    return targetElPosition;\n  }\n\n  private autoPosition(\n    targetElPosition: ClientRect,\n    hostElPosition: ClientRect,\n    targetElement: HTMLElement,\n    preferredPosition?: string\n  ) {\n    if (\n      (!preferredPosition || preferredPosition === 'right') &&\n      targetElPosition.left + hostElPosition.left - targetElPosition.width <\n        0\n    ) {\n      return 'right';\n    } else if (\n      (!preferredPosition || preferredPosition === 'top') &&\n      targetElPosition.bottom +\n        hostElPosition.bottom +\n        targetElPosition.height >\n        window.innerHeight\n    ) {\n      return 'top';\n    } else if (\n      (!preferredPosition || preferredPosition === 'bottom') &&\n      targetElPosition.top + hostElPosition.top - targetElPosition.height < 0\n    ) {\n      return 'bottom';\n    } else if (\n      (!preferredPosition || preferredPosition === 'left') &&\n      targetElPosition.right +\n        hostElPosition.right +\n        targetElPosition.width >\n        window.innerWidth\n    ) {\n      return 'left';\n    }\n    return null;\n  }\n\n  private getAllStyles(element: HTMLElement) {\n    return window.getComputedStyle(element);\n  }\n\n  private getStyle(element: HTMLElement, prop: string): string {\n    return (this.getAllStyles(element) as any)[prop];\n  }\n\n  private isStaticPositioned(element: HTMLElement): boolean {\n    return (this.getStyle(element, 'position') || 'static') === 'static';\n  }\n\n  private offsetParent(element: HTMLElement): HTMLElement {\n    let offsetParentEl =\n      <HTMLElement>element.offsetParent || document.documentElement;\n\n    while (\n      offsetParentEl &&\n      offsetParentEl !== document.documentElement &&\n      this.isStaticPositioned(offsetParentEl)\n    ) {\n      offsetParentEl = <HTMLElement>offsetParentEl.offsetParent;\n    }\n\n    return offsetParentEl || document.documentElement;\n  }\n}\n\nconst positionService = new Positioning();\n\nexport function positionElements(\n  hostElement: HTMLElement,\n  targetElement: HTMLElement,\n  placement: string,\n  appendToBody?: boolean\n): void {\n  const pos = positionService.positionElements(\n    hostElement,\n    targetElement,\n    placement,\n    appendToBody\n  );\n\n  targetElement.style.top = `${pos.top}px`;\n  targetElement.style.left = `${pos.left}px`;\n}\n","import { Injectable, ElementRef } from '@angular/core';\nimport { positionElements } from './ng-positioning';\n\nexport interface PositioningOptions {\n  /** The DOM element, ElementRef, or a selector string of an element which will be moved */\n  element?: HTMLElement | ElementRef | string;\n\n  /** The DOM element, ElementRef, or a selector string of an element which the element will be attached to  */\n  target?: HTMLElement | ElementRef | string;\n\n  /**\n   * A string of the form 'vert-attachment horiz-attachment' or 'placement'\n   * - placement can be \"top\", \"bottom\", \"left\", \"right\"\n   * not yet supported:\n   * - vert-attachment can be any of 'top', 'middle', 'bottom'\n   * - horiz-attachment can be any of 'left', 'center', 'right'\n   */\n  attachment?: string;\n\n  /** A string similar to `attachment`. The one difference is that, if it's not provided,\n   * `targetAttachment` will assume the mirror image of `attachment`.\n   */\n  targetAttachment?: string;\n\n  /** A string of the form 'vert-offset horiz-offset'\n   * - vert-offset and horiz-offset can be of the form \"20px\" or \"55%\"\n   */\n  offset?: string;\n\n  /** A string similar to `offset`, but referring to the offset of the target */\n  targetOffset?: string;\n\n  /** If true component will be attached to body */\n  appendToBody?: boolean;\n}\n\n@Injectable()\nexport class PositioningService {\n  position(options: PositioningOptions): void {\n    const {element, target, attachment, appendToBody} = options;\n    positionElements(\n      _getHtmlElement(target),\n      _getHtmlElement(element),\n      attachment,\n      appendToBody\n    );\n  }\n\n}\n\nfunction _getHtmlElement(element: HTMLElement | ElementRef | string): HTMLElement {\n  // it means that we got a selector\n  if (typeof element === 'string') {\n    return document.querySelector(element);\n  }\n\n  if (element instanceof ElementRef) {\n    return element.nativeElement;\n  }\n\n  return element;\n}\n"],"names":["Injectable","ElementRef"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-positioning.umd.js.map","sources":["node_modules/tslib/tslib.es6.js","ng://ngx-bootstrap/positioning/utils/getStyleComputedProperty.ts","ng://ngx-bootstrap/positioning/utils/getParentNode.ts","ng://ngx-bootstrap/positioning/utils/getScrollParent.ts","ng://ngx-bootstrap/positioning/utils/isBrowser.ts","ng://ngx-bootstrap/positioning/utils/isIE.ts","ng://ngx-bootstrap/positioning/utils/getOffsetParent.ts","ng://ngx-bootstrap/positioning/utils/isOffsetContainer.ts","ng://ngx-bootstrap/positioning/utils/getRoot.ts","ng://ngx-bootstrap/positioning/utils/findCommonOffsetParent.ts","ng://ngx-bootstrap/positioning/utils/getBordersSize.ts","ng://ngx-bootstrap/positioning/utils/getWindowSizes.ts","ng://ngx-bootstrap/positioning/utils/getScroll.ts","ng://ngx-bootstrap/positioning/utils/getClientRect.ts","ng://ngx-bootstrap/positioning/utils/getBoundingClientRect.ts","ng://ngx-bootstrap/positioning/utils/includeScroll.ts","ng://ngx-bootstrap/positioning/utils/getOffsetRectRelativeToArbitraryNode.ts","ng://ngx-bootstrap/positioning/utils/getViewportOffsetRectRelativeToArtbitraryNode.ts","ng://ngx-bootstrap/positioning/utils/isFixed.ts","ng://ngx-bootstrap/positioning/utils/getFixedPositionOffsetParent.ts","ng://ngx-bootstrap/positioning/utils/getBoundaries.ts","ng://ngx-bootstrap/positioning/utils/computeAutoPlacement.ts","ng://ngx-bootstrap/positioning/utils/getOffsets.ts","ng://ngx-bootstrap/positioning/utils/getOppositePlacement.ts","ng://ngx-bootstrap/positioning/utils/getOppositeVariation.ts","ng://ngx-bootstrap/positioning/utils/getOuterSizes.ts","ng://ngx-bootstrap/positioning/utils/getReferenceOffsets.ts","ng://ngx-bootstrap/positioning/utils/getTargetOffsets.ts","ng://ngx-bootstrap/positioning/utils/isNumeric.ts","ng://ngx-bootstrap/positioning/utils/setAllStyles.ts","ng://ngx-bootstrap/positioning/utils/setStyles.ts","ng://ngx-bootstrap/positioning/modifiers/arrow.ts","ng://ngx-bootstrap/positioning/modifiers/flip.ts","ng://ngx-bootstrap/positioning/modifiers/initData.ts","ng://ngx-bootstrap/positioning/modifiers/preventOverflow.ts","ng://ngx-bootstrap/positioning/modifiers/shift.ts","ng://ngx-bootstrap/positioning/ng-positioning.ts","ng://ngx-bootstrap/positioning/positioning.service.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/**\n * Get CSS computed property of the given element\n */\nexport function getStyleComputedProperty(element: HTMLElement, property?: string): any {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  const window = element.ownerDocument.defaultView;\n  const css = window.getComputedStyle(element, null);\n\n  return property ? css[property] : css;\n}\n","/**\n * Returns the parentNode or the host of the element\n */\nexport function getParentNode(element: any): any {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n\n  return element.parentNode || element.host;\n}\n","/**\n * Returns the scrolling parent of the given element\n */\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { getParentNode } from './getParentNode';\n\nexport function getScrollParent(element: any): any {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  if (!element) {\n    return document.body;\n  }\n\n  switch (element.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return element.ownerDocument.body;\n    case '#document':\n      return element.body;\n    default:\n  }\n\n  // Firefox want us to check `-x` and `-y` variations as well\n  const { overflow, overflowX, overflowY } = getStyleComputedProperty(element);\n  if (/(auto|scroll|overlay)/.test(String(overflow) + String(overflowY) + String(overflowX))) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\n}\n","export const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\n","/**\n * Determines if the browser is Internet Explorer\n */\nimport { isBrowser } from './isBrowser';\n\nconst isIE11 = isBrowser && !!((window as any).MSInputMethodContext && (document as any).documentMode);\nconst isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);\n\nexport function isIE(version?: number) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n\n  return isIE11 || isIE10;\n}\n","/**\n * Returns the offset parent of the given element\n */\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { isIE } from './isIE';\n\nexport function getOffsetParent(element: any): any {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  const noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  let offsetParent = element.offsetParent || null;\n  // Skip hidden elements which don't have an offsetParent\n\n  let sibling: any;\n\n  while (offsetParent === noOffsetParent && element.nextElementSibling) {\n    sibling = element.nextElementSibling;\n    offsetParent = sibling.offsetParent;\n  }\n\n  const nodeName = offsetParent && offsetParent.nodeName;\n\n  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {\n    return sibling ? sibling.ownerDocument.documentElement : document.documentElement;\n  }\n\n  // .offsetParent will return the closest TH, TD or TABLE in case\n  // no offsetParent is present, I hate this job...\n  if (\n    ['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 &&\n    getStyleComputedProperty(offsetParent, 'position') === 'static'\n  ) {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\n}\n","import { getOffsetParent } from './getOffsetParent';\n\nexport function isOffsetContainer(element: any) {\n  const { nodeName } = element;\n  if (nodeName === 'BODY') {\n    return false;\n  }\n\n  return (\n    nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element\n  );\n}\n","/**\n * Finds the root node (document, shadowDOM root) of the given element\n */\nexport function getRoot(node: Node): any {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n","/**\n * Finds the offset parent common to the two provided nodes\n */\nimport { isOffsetContainer } from './isOffsetContainer';\nimport { getRoot } from './getRoot';\nimport { getOffsetParent } from './getOffsetParent';\n\nexport function findCommonOffsetParent(element1: HTMLElement, element2: HTMLElement): any {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {\n    return document.documentElement;\n  }\n\n  // Here we make sure to give as \"start\" the element that comes first in the DOM\n  /* tslint:disable-next-line: no-bitwise */\n  const order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;\n\n  const start = order ? element1 : element2;\n  const end = order ? element2 : element1;\n\n  // Get common ancestor container\n  const range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  const { commonAncestorContainer } = range;\n\n  // Both nodes are inside #document\n  if (\n    (element1 !== commonAncestorContainer &&\n      element2 !== commonAncestorContainer) ||\n    start.contains(end)\n  ) {\n    if (isOffsetContainer(commonAncestorContainer)) {\n      return commonAncestorContainer;\n    }\n\n    return getOffsetParent(commonAncestorContainer);\n  }\n\n  // one of the nodes is inside shadowDOM, find which one\n  const element1root = getRoot(element1);\n  if (element1root.host) {\n    return findCommonOffsetParent(element1root.host, element2);\n  } else {\n    return findCommonOffsetParent(element1, getRoot(element2).host);\n  }\n}\n","/**\n * Helper to detect borders of a given element\n */\n\nexport function getBordersSize(styles: CSSStyleDeclaration, axis: string) {\n  const sideA = axis === 'x' ? 'Left' : 'Top';\n  const sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return (\n    parseFloat(styles[`border${sideA}Width`]) +\n    parseFloat(styles[`border${sideB}Width`])\n  );\n}\n","import { isIE } from './isIE';\n\nfunction getSize(axis: string, body: HTMLElement, html: HTMLElement, computedStyle: CSSStyleDeclaration) {\n  return Math.max(\n    body[`offset${axis}`],\n    body[`scroll${axis}`],\n    html[`client${axis}`],\n    html[`offset${axis}`],\n    html[`scroll${axis}`],\n    isIE(10)\n      ? (parseInt(html[`offset${axis}`], 10) +\n      parseInt(computedStyle[`margin${axis === 'Height' ? 'Top' : 'Left'}`], 10) +\n      parseInt(computedStyle[`margin${axis === 'Height' ? 'Bottom' : 'Right'}`], 10))\n    : 0\n  );\n}\n\nexport function getWindowSizes(document: Document) {\n  const body = document.body;\n  const html = document.documentElement;\n  const computedStyle = isIE(10) && getComputedStyle(html);\n\n  return {\n    height: getSize('Height', body, html, computedStyle),\n    width: getSize('Width', body, html, computedStyle)\n  };\n}\n","/**\n * Gets the scroll value of the given element in the given side (top and left)\n */\nexport function getScroll(element: HTMLElement, side = 'top') {\n  const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  const nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    const html = element.ownerDocument.documentElement;\n    const scrollingElement = element.ownerDocument.scrollingElement || html;\n\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n","/**\n * Given element offsets, generate an output similar to getBoundingClientRect\n */\nimport { Offsets } from '../models';\n\nexport function getClientRect(offsets: Offsets): Offsets {\n  return {\n    ...offsets,\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height\n  };\n}\n","/**\n * Get bounding client rect of given element\n */\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { getBordersSize } from './getBordersSize';\nimport { getWindowSizes } from './getWindowSizes';\nimport { getScroll } from './getScroll';\nimport { getClientRect } from './getClientRect';\nimport { isIE } from './isIE';\nimport { Offsets } from '../models';\n\nexport function getBoundingClientRect(element: HTMLElement): Offsets {\n  let rect: any = {};\n\n  // IE10 10 FIX: Please, don't ask, the element isn't\n  // considered in DOM in some circumstances...\n  // This isn't reproducible in IE10 compatibility mode of IE11\n  try {\n    if (isIE(10)) {\n      rect = element.getBoundingClientRect();\n      const scrollTop = getScroll(element, 'top');\n      const scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    } else {\n      rect = element.getBoundingClientRect();\n    }\n  } catch (e) {\n    return undefined;\n  }\n\n  const result: any = {\n    left: rect.left,\n    top: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n\n  // subtract scrollbar size from sizes\n  const sizes: any = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  const width =\n    sizes.width || element.clientWidth || result.right - result.left;\n  const height =\n    sizes.height || element.clientHeight || result.bottom - result.top;\n\n  let horizScrollbar = element.offsetWidth - width;\n  let vertScrollbar = element.offsetHeight - height;\n\n  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`\n  // we make this check conditional for performance reasons\n  if (horizScrollbar || vertScrollbar) {\n    const styles = getStyleComputedProperty(element);\n    horizScrollbar -= getBordersSize(styles, 'x');\n    vertScrollbar -= getBordersSize(styles, 'y');\n\n    result.width -= horizScrollbar;\n    result.height -= vertScrollbar;\n  }\n\n  return getClientRect(result);\n}\n","/**\n * Sum or subtract the element scroll values (left and top) from a given rect object\n */\nimport { getScroll } from './getScroll';\nimport { Offsets } from '../models';\n\nexport function includeScroll(rect: Offsets, element: HTMLElement, subtract = false) {\n  const scrollTop = getScroll(element, 'top');\n  const scrollLeft = getScroll(element, 'left');\n  const modifier = subtract ? -1 : 1;\n  rect.top += scrollTop * modifier;\n  rect.bottom += scrollTop * modifier;\n  rect.left += scrollLeft * modifier;\n  rect.right += scrollLeft * modifier;\n\n  return rect;\n}\n","import { getBoundingClientRect } from './getBoundingClientRect';\nimport { getClientRect } from './getClientRect';\nimport { getScrollParent } from './getScrollParent';\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { includeScroll } from './includeScroll';\nimport { isIE as runIsIE } from './isIE';\nimport { Offsets } from '../models';\n\nexport function getOffsetRectRelativeToArbitraryNode(\n  children: HTMLElement,\n  parent: HTMLElement,\n  fixedPosition = false\n): Offsets {\n  const isIE10 = runIsIE(10);\n  const isHTML = parent.nodeName === 'HTML';\n  const childrenRect: any = getBoundingClientRect(children);\n  const parentRect: any = getBoundingClientRect(parent);\n  const scrollParent = getScrollParent(children);\n\n  const styles = getStyleComputedProperty(parent);\n  const borderTopWidth = parseFloat(styles.borderTopWidth);\n  const borderLeftWidth = parseFloat(styles.borderLeftWidth);\n\n  // In cases where the parent is fixed, we must ignore negative scroll in offset calc\n  if (fixedPosition && isHTML) {\n    parentRect.top = Math.max(parentRect.top, 0);\n    parentRect.left = Math.max(parentRect.left, 0);\n  }\n\n  let offsets: Offsets = getClientRect({\n    top: childrenRect.top - parentRect.top - borderTopWidth,\n    left: childrenRect.left - parentRect.left - borderLeftWidth,\n    width: childrenRect.width,\n    height: childrenRect.height\n  });\n\n  offsets.marginTop = 0;\n  offsets.marginLeft = 0;\n\n  // Subtract margins of documentElement in case it's being used as parent\n  // we do this only on HTML because it's the only element that behaves\n  // differently when margins are applied to it. The margins are included in\n  // the box of the documentElement, in the other cases not.\n  if (!isIE10 && isHTML) {\n    const marginTop = parseFloat(styles.marginTop);\n    const marginLeft = parseFloat(styles.marginLeft);\n\n    offsets.top -= borderTopWidth - marginTop;\n    offsets.bottom -= borderTopWidth - marginTop;\n    offsets.left -= borderLeftWidth - marginLeft;\n    offsets.right -= borderLeftWidth - marginLeft;\n\n    // Attach marginTop and marginLeft because in some circumstances we may need them\n    offsets.marginTop = marginTop;\n    offsets.marginLeft = marginLeft;\n  }\n\n  if (\n    isIE10 && !fixedPosition\n      ? parent.contains(scrollParent)\n      : parent === scrollParent && scrollParent.nodeName !== 'BODY'\n  ) {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n","import { getClientRect } from './getClientRect';\nimport { getOffsetRectRelativeToArbitraryNode } from './getOffsetRectRelativeToArbitraryNode';\nimport { getScroll } from './getScroll';\nimport { Offsets } from '../models';\n\nexport function getViewportOffsetRectRelativeToArtbitraryNode(element: HTMLElement, excludeScroll = false): Offsets {\n  const html = element.ownerDocument.documentElement;\n  const relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  const width = Math.max(html.clientWidth, window.innerWidth || 0);\n  const height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  const scrollTop = !excludeScroll ? getScroll(html) : 0;\n  const scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  const offset = {\n    top: scrollTop - Number(relativeOffset.top) + Number(relativeOffset.marginTop),\n    left: scrollLeft - Number(relativeOffset.left) + Number(relativeOffset.marginLeft),\n    width,\n    height\n  };\n\n  return getClientRect(offset);\n}\n","/**\n * Check if the given element is fixed or is inside a fixed parent\n */\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { getParentNode } from './getParentNode';\n\nexport function isFixed(element: HTMLElement): boolean {\n  const nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n\n  return isFixed(getParentNode(element));\n}\n","/**\n * Finds the first parent of an element that has a transformed property defined\n */\n\nimport { getStyleComputedProperty } from './getStyleComputedProperty';\nimport { isIE } from './isIE';\n\nexport function getFixedPositionOffsetParent(element: HTMLElement): HTMLElement {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element || !element.parentElement || isIE()) {\n   return document.documentElement;\n  }\n\n  let el = element.parentElement;\n\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n\n  return el || document.documentElement;\n}\n","/**\n * Computed the boundaries limits and return them\n */\nimport { getScrollParent } from './getScrollParent';\nimport { getParentNode } from './getParentNode';\nimport { findCommonOffsetParent } from './findCommonOffsetParent';\nimport { getOffsetRectRelativeToArbitraryNode } from './getOffsetRectRelativeToArbitraryNode';\nimport { getViewportOffsetRectRelativeToArtbitraryNode } from './getViewportOffsetRectRelativeToArtbitraryNode';\nimport { getWindowSizes } from './getWindowSizes';\nimport { isFixed } from './isFixed';\nimport { getFixedPositionOffsetParent } from './getFixedPositionOffsetParent';\n\nexport function getBoundaries(\n  target: HTMLElement,\n  host: HTMLElement,\n  padding = 0,\n  boundariesElement: string,\n  fixedPosition = false\n) {\n  // NOTE: 1 DOM access here\n\n  let boundaries: any = { top: 0, left: 0 };\n  const offsetParent = fixedPosition ? getFixedPositionOffsetParent(target) : findCommonOffsetParent(target, host);\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport') {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  } else {\n    // Handle other cases based on DOM element used as boundaries\n    let boundariesNode;\n    if (boundariesElement === 'scrollParent') {\n      boundariesNode = getScrollParent(getParentNode(host));\n      if (boundariesNode.nodeName === 'BODY') {\n        boundariesNode = target.ownerDocument.documentElement;\n      }\n    } else if (boundariesElement === 'window') {\n      boundariesNode = target.ownerDocument.documentElement;\n    } else {\n      boundariesNode = boundariesElement;\n    }\n\n    const offsets = getOffsetRectRelativeToArbitraryNode(\n      boundariesNode,\n      offsetParent,\n      fixedPosition\n    );\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      const { height, width } = getWindowSizes(target.ownerDocument);\n      boundaries.top += offsets.top - offsets.marginTop;\n      boundaries.bottom = Number(height) + Number(offsets.top);\n      boundaries.left += offsets.left - offsets.marginLeft;\n      boundaries.right = Number(width) + Number(offsets.left);\n    } else {\n      // for all the other DOM elements, this one is good\n      boundaries = offsets;\n    }\n  }\n\n  // Add paddings\n  boundaries.left += padding;\n  boundaries.top += padding;\n  boundaries.right -= padding;\n  boundaries.bottom -= padding;\n\n  return boundaries;\n}\n","/**\n * Utility used to transform the `auto` placement to the placement with more\n * available space.\n */\nimport { getBoundaries } from './getBoundaries';\nimport { Offsets } from '../models';\n\nfunction getArea({ width, height }: { [key: string]: number }) {\n  return width * height;\n}\n\nexport function computeAutoPlacement(\n  placement: string,\n  refRect: Offsets,\n  target: HTMLElement,\n  host: HTMLElement,\n  boundariesElement: string,\n  padding = 0\n) {\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  if (placement.indexOf('auto') !== -1\n    && (placement.indexOf('left') !== -1\n    || placement.indexOf('right') !== -1\n    || placement.indexOf('top') !== -1\n    || placement.indexOf('bottom') !== -1)) {\n\n    return placement.split(' ')[1] || '';\n  }\n\n  const boundaries = getBoundaries(target, host, padding, boundariesElement);\n\n  const rects: any = {\n    top: {\n      width: boundaries.width,\n      height: refRect.top - boundaries.top\n    },\n    right: {\n      width: boundaries.right - refRect.right,\n      height: boundaries.height\n    },\n    bottom: {\n      width: boundaries.width,\n      height: boundaries.bottom - refRect.bottom\n    },\n    left: {\n      width: refRect.left - boundaries.left,\n      height: boundaries.height\n    }\n  };\n\n  const sortedAreas = Object.keys(rects)\n    .map(key => ({\n      key,\n      ...rects[key],\n      area: getArea(rects[key])\n    }))\n    .sort((a, b) => b.area - a.area);\n\n  const filteredAreas = sortedAreas.filter(\n    ({ width, height }) =>\n      width >= target.clientWidth && height >= target.clientHeight\n  );\n\n  const computedPlacement: string = filteredAreas.length > 0\n    ? filteredAreas[0].key\n    : sortedAreas[0].key;\n\n  const variation = placement.split(' ')[1];\n\n  target.className = target.className.replace(/auto/g, computedPlacement);\n\n  return computedPlacement + (variation ? `-${variation}` : '');\n}\n","import { Data, Offsets } from '../models';\n\nexport function getOffsets(data: Data): Offsets {\n  return {\n    width: data.offsets.target.width,\n    height: data.offsets.target.height,\n    left: Math.floor(data.offsets.target.left),\n    top: Math.round(data.offsets.target.top),\n    bottom: Math.round(data.offsets.target.bottom),\n    right: Math.floor(data.offsets.target.right)\n  };\n}\n","/**\n * Get the opposite placement of the given one\n */\nexport function getOppositePlacement(placement: string) {\n  const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n\n  return placement.replace(/left|right|bottom|top/g, matched => hash[matched]);\n}\n","/**\n * Get the opposite placement variation of the given one\n */\nexport function getOppositeVariation(variation: string) {\n  if (variation === 'right') {\n    return 'left';\n  } else if (variation === 'left') {\n    return 'right';\n  }\n\n  return variation;\n}\n","/**\n * Get the outer sizes of the given element (offset size + margins)\n */\nexport function getOuterSizes(element: any) {\n  const window = element.ownerDocument.defaultView;\n  const styles = window.getComputedStyle(element);\n  const x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  const y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n\n  return {\n    width: Number(element.offsetWidth) + y,\n    height: Number(element.offsetHeight) + x\n  };\n}\n","/**\n * Get offsets to the reference element\n */\nimport { findCommonOffsetParent } from './findCommonOffsetParent';\nimport { getOffsetRectRelativeToArbitraryNode } from './getOffsetRectRelativeToArbitraryNode';\nimport { getFixedPositionOffsetParent } from './getFixedPositionOffsetParent';\nimport { Offsets } from '../models';\n\nexport function getReferenceOffsets(\n  target: HTMLElement,\n  host: HTMLElement,\n  fixedPosition: boolean = null\n): Offsets {\n  const commonOffsetParent = fixedPosition\n    ? getFixedPositionOffsetParent(target)\n    : findCommonOffsetParent(target, host);\n\n  return getOffsetRectRelativeToArbitraryNode(host, commonOffsetParent, fixedPosition);\n}\n","/**\n * Get offsets to the target\n */\nimport { getOppositePlacement } from './getOppositePlacement';\nimport { getOuterSizes } from './getOuterSizes';\nimport { Offsets } from '../models';\n\nexport function getTargetOffsets(\n  target: HTMLElement,\n  hostOffsets: Offsets,\n  position: string\n): Offsets {\n  const placement = position.split(' ')[0];\n\n  // Get target node sizes\n  const targetRect = getOuterSizes(target);\n\n  // Add position, width and height to our offsets object\n  const targetOffsets = {\n    width: targetRect.width,\n    height: targetRect.height\n  };\n\n  // depending by the target placement we have to compute its offsets slightly differently\n  const isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  const mainSide = isHoriz ? 'top' : 'left';\n  const secondarySide = isHoriz ? 'left' : 'top';\n  const measurement = isHoriz ? 'height' : 'width';\n  const secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  targetOffsets[mainSide] =\n    hostOffsets[mainSide] +\n    hostOffsets[measurement] / 2 -\n    targetRect[measurement] / 2;\n\n  targetOffsets[secondarySide] = placement === secondarySide\n    ? hostOffsets[secondarySide] - targetRect[secondaryMeasurement]\n    : hostOffsets[getOppositePlacement(secondarySide)];\n\n  return targetOffsets;\n}\n","/**\n * Tells if a given input is a number\n */\nexport function isNumeric(n: any) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n","/**\n * Set the style to the given popper\n */\nimport { Renderer2 } from '@angular/core';\n\nimport { Data } from '../models';\nimport { getOffsets, setStyles } from './index';\n\nexport function setAllStyles(data: Data, renderer?: Renderer2): void {\n  const target = data.instance.target;\n\n  const offsets = getOffsets(data);\n\n  setStyles(target, {\n    'will-change': 'transform',\n    top: '0px',\n    left: '0px',\n    transform: `translate3d(${offsets.left}px, ${offsets.top}px, 0px)`\n  }, renderer);\n\n  if (data.instance.arrow) {\n    setStyles(data.instance.arrow, data.offsets.arrow, renderer);\n  }\n\n  if (data.placementAuto) {\n    if (renderer) {\n      renderer.setAttribute(target, 'class',\n        target.className.replace(/bs-popover-auto/g, `bs-popover-${data.placement}`)\n      );\n      renderer.setAttribute(target, 'class',\n        target.className.replace(/bs-tooltip-auto/g, `bs-tooltip-${data.placement}`)\n      );\n\n      renderer.setAttribute(target, 'class',\n        target.className.replace(/\\sauto/g, `\\s${data.placement}`)\n      );\n\n      if (target.className.match(/popover/g)) {\n        renderer.addClass(target, 'popover-auto');\n      }\n\n      if (target.className.match(/tooltip/g)) {\n        renderer.addClass(target, 'tooltip-auto');\n      }\n\n\n    } else {\n      target.className = target.className.replace(/bs-popover-auto/g, `bs-popover-${data.placement}`);\n      target.className = target.className.replace(/bs-tooltip-auto/g, `bs-tooltip-${data.placement}`);\n      target.className = target.className.replace(/\\sauto/g, `\\s${data.placement}`);\n\n      if (target.className.match(/popover/g)) {\n        target.classList.add('popover-auto');\n      }\n\n      if (target.className.match(/tooltip/g)) {\n        target.classList.add('tooltip-auto');\n      }\n    }\n  }\n\n  if (renderer) {\n    renderer.setAttribute(target, 'class', target.className.replace(/left|right|top|bottom/g, `${data.placement}`));\n  } else {\n    target.className = target.className.replace(/left|right|top|bottom/g, `${data.placement}`);\n  }\n}\n","/**\n * Set the style to the given popper\n */\nimport { Renderer2 } from '@angular/core';\n\nimport { isNumeric } from './isNumeric';\n\nexport function setStyles(element: HTMLElement, styles: any, renderer?: Renderer2) {\n  Object.keys(styles).forEach((prop: any) => {\n    let unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 &&\n      isNumeric(styles[prop])) {\n      unit = 'px';\n    }\n\n    if (renderer) {\n      renderer.setStyle(element, prop, `${String(styles[prop])}${unit}`);\n\n      return;\n    }\n\n    element.style[prop] = String(styles[prop]) + unit;\n  });\n}\n","import { getClientRect, getOuterSizes, getStyleComputedProperty } from '../utils';\nimport { Data } from '../models';\n\nexport function arrow(data: Data) {\n  let targetOffsets = data.offsets.target;\n  // if arrowElement is a string, suppose it's a CSS selector\n  const arrowElement: HTMLElement | null = data.instance.target.querySelector('.arrow');\n\n  // if arrowElement is not found, don't run the modifier\n  if (!arrowElement) {\n    return data;\n  }\n\n  const isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n\n  const len = isVertical ? 'height' : 'width';\n  const sideCapitalized = isVertical ? 'Top' : 'Left';\n  const side = sideCapitalized.toLowerCase();\n  const altSide = isVertical ? 'left' : 'top';\n  const opSide = isVertical ? 'bottom' : 'right';\n  const arrowElementSize = getOuterSizes(arrowElement)[len];\n\n  // top/left side\n  if (data.offsets.host[opSide] - arrowElementSize < targetOffsets[side]) {\n    targetOffsets[side] -=\n      targetOffsets[side] - (data.offsets.host[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (Number(data.offsets.host[side]) + Number(arrowElementSize) > targetOffsets[opSide]) {\n    targetOffsets[side] +=\n      Number(data.offsets.host[side]) + Number(arrowElementSize) - Number(targetOffsets[opSide]);\n  }\n  targetOffsets = getClientRect(targetOffsets);\n\n  // compute center of the target\n  const center = Number(data.offsets.host[side]) + Number(data.offsets.host[len] / 2 - arrowElementSize / 2);\n\n  // Compute the sideValue using the updated target offsets\n  // take target margin in account because we don't have this info available\n  const css = getStyleComputedProperty(data.instance.target);\n\n  const targetMarginSide = parseFloat(css[`margin${sideCapitalized}`]);\n  const targetBorderSide = parseFloat(css[`border${sideCapitalized}Width`]);\n  let sideValue =\n    center - targetOffsets[side] - targetMarginSide - targetBorderSide;\n\n  // prevent arrowElement from being placed not contiguously to its target\n  sideValue = Math.max(Math.min(targetOffsets[len] - arrowElementSize, sideValue), 0);\n\n  data.offsets.arrow = {\n    [side]: Math.round(sideValue),\n    [altSide]: '' // make sure to unset any eventual altSide value from the DOM node\n  };\n\n  data.instance.arrow = arrowElement;\n\n  return data;\n}\n","import {\n  computeAutoPlacement,\n  getBoundaries, getClientRect,\n  getOppositePlacement,\n  getOppositeVariation,\n  getTargetOffsets\n} from '../utils';\n\nimport { Data } from '../models';\n\nexport function flip(data: Data): Data {\n  data.offsets.target = getClientRect(data.offsets.target);\n\n  const boundaries = getBoundaries(\n    data.instance.target,\n    data.instance.host,\n    0, // padding\n    'viewport',\n    false // positionFixed\n  );\n\n  let placement = data.placement.split(' ')[0];\n  let variation = data.placement.split(' ')[1] || '';\n\n  const adaptivePosition = variation\n    ? getOppositePlacement(placement)\n    : computeAutoPlacement('auto', data.offsets.host, data.instance.target, data.instance.host, 'viewport', 0);\n\n  const flipOrder = [placement, adaptivePosition];\n\n  /* tslint:disable-next-line: cyclomatic-complexity */\n  flipOrder.forEach((step, index) => {\n    if (placement !== step || flipOrder.length === index + 1) {\n      return data;\n    }\n\n    placement = data.placement.split(' ')[0];\n\n    // using floor because the host offsets may contain decimals we are not going to consider here\n    const overlapsRef =\n      (placement === 'left' &&\n        Math.floor(data.offsets.target.right) > Math.floor(data.offsets.host.left)) ||\n      (placement === 'right' &&\n        Math.floor(data.offsets.target.left) < Math.floor(data.offsets.host.right)) ||\n      (placement === 'top' &&\n        Math.floor(data.offsets.target.bottom) > Math.floor(data.offsets.host.top)) ||\n      (placement === 'bottom' &&\n        Math.floor(data.offsets.target.top) < Math.floor(data.offsets.host.bottom));\n\n    const overflowsLeft = Math.floor(data.offsets.target.left) < Math.floor(boundaries.left);\n    const overflowsRight = Math.floor(data.offsets.target.right) > Math.floor(boundaries.right);\n    const overflowsTop = Math.floor(data.offsets.target.top) < Math.floor(boundaries.top);\n    const overflowsBottom = Math.floor(data.offsets.target.bottom) > Math.floor(boundaries.bottom);\n\n    const overflowsBoundaries =\n      (placement === 'left' && overflowsLeft) ||\n      (placement === 'right' && overflowsRight) ||\n      (placement === 'top' && overflowsTop) ||\n      (placement === 'bottom' && overflowsBottom);\n\n    // flip the variation if required\n    const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n    const flippedVariation =\n      ((isVertical && variation === 'left' && overflowsLeft) ||\n        (isVertical && variation === 'right' && overflowsRight) ||\n        (!isVertical && variation === 'left' && overflowsTop) ||\n        (!isVertical && variation === 'right' && overflowsBottom));\n\n    if (overlapsRef || overflowsBoundaries || flippedVariation) {\n      // this boolean to detect any flip loop\n      if (overlapsRef || overflowsBoundaries) {\n        placement = flipOrder[index + 1];\n      }\n\n      if (flippedVariation) {\n        variation = getOppositeVariation(variation);\n      }\n\n      data.placement = placement + (variation ? ` ${variation}` : '');\n\n      data.offsets.target = {\n        ...data.offsets.target,\n        ...getTargetOffsets(\n          data.instance.target,\n          data.offsets.host,\n          data.placement\n        )\n      };\n    }\n  });\n\n  return data;\n}\n","import {\n  computeAutoPlacement,\n  getReferenceOffsets,\n  getTargetOffsets\n} from '../utils';\n\nimport { Data } from '../models';\n\nexport function initData(targetElement: HTMLElement, hostElement: HTMLElement, position: string): Data {\n\n  const hostElPosition = getReferenceOffsets(targetElement, hostElement);\n  const targetOffset = getTargetOffsets(targetElement, hostElPosition, position);\n\n  const placement = computeAutoPlacement(position, hostElPosition, targetElement, hostElement, 'viewport', 0);\n  const placementAuto = position.indexOf('auto') !== -1;\n\n  return {\n    instance: {\n      target: targetElement,\n      host: hostElement,\n      arrow: null\n    },\n    offsets: {\n      target: targetOffset,\n      host: hostElPosition,\n      arrow: null\n    },\n    positionFixed: false,\n    placement,\n    placementAuto\n  };\n}\n","import { getBoundaries } from '../utils';\nimport { Data } from '../models';\n\nexport function preventOverflow(data: Data) {\n\n  // NOTE: DOM access here\n  // resets the targetOffsets's position so that the document size can be calculated excluding\n  // the size of the targetOffsets element itself\n  const transformProp = 'transform';\n  const targetStyles = data.instance.target.style; // assignment to help minification\n  const { top, left, [transformProp]: transform } = targetStyles;\n  targetStyles.top = '';\n  targetStyles.left = '';\n  targetStyles[transformProp] = '';\n\n  const boundaries = getBoundaries(\n    data.instance.target,\n    data.instance.host,\n    0, // padding\n    'scrollParent',\n    false // positionFixed\n  );\n\n  // NOTE: DOM access here\n  // restores the original style properties after the offsets have been computed\n  targetStyles.top = top;\n  targetStyles.left = left;\n  targetStyles[transformProp] = transform;\n\n  const order = ['left', 'right', 'top', 'bottom'];\n\n  const check = {\n    primary(placement: string) {\n      let value = data.offsets.target[placement];\n      if (\n        data.offsets.target[placement] < boundaries[placement] &&\n        !false // options.escapeWithReference\n      ) {\n        value = Math.max(data.offsets.target[placement], boundaries[placement]);\n      }\n\n      return { [placement]: value };\n    },\n    secondary(placement: string) {\n      const mainSide = placement === 'right' ? 'left' : 'top';\n      let value = data.offsets.target[mainSide];\n      if (\n        data.offsets.target[placement] > boundaries[placement] &&\n        !false // escapeWithReference\n      ) {\n        value = Math.min(\n          data.offsets.target[mainSide],\n          boundaries[placement] -\n          (placement === 'right' ? data.offsets.target.width : data.offsets.target.height)\n        );\n      }\n\n      return { [mainSide]: value };\n    }\n  };\n\n  let side: string;\n\n  order.forEach(placement => {\n    side = ['left', 'top']\n      .indexOf(placement) !== -1\n      ? 'primary'\n      : 'secondary';\n\n    data.offsets.target = { ...data.offsets.target, ...check[side](placement) };\n\n  });\n\n  return data;\n}\n","import { Data } from '../models';\n\nexport function shift(data: Data): Data {\n  const placement = data.placement;\n  const basePlacement = placement.split(' ')[0];\n  const shiftvariation = placement.split(' ')[1];\n\n  if (shiftvariation) {\n    const { host, target } = data.offsets;\n    const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    const side = isVertical ? 'left' : 'top';\n    const measurement = isVertical ? 'width' : 'height';\n\n    const shiftOffsets = {\n      left: { [side]: host[side] },\n      right: {\n        [side]: host[side] + host[measurement] - host[measurement]\n      }\n    };\n\n    data.offsets.target = { ...target, ...shiftOffsets[shiftvariation] };\n  }\n\n  return data;\n}\n","/**\n * @copyright Valor Software\n * @copyright Federico Zivolo and contributors\n */\nimport { Renderer2 } from '@angular/core';\n\nimport { getReferenceOffsets, setAllStyles } from './utils';\n\nimport { arrow, flip, preventOverflow, shift, initData } from './modifiers';\nimport { Data, Offsets } from './models';\n\n\nexport class Positioning {\n  position(hostElement: HTMLElement, targetElement: HTMLElement, round = true): Offsets {\n    return this.offset(hostElement, targetElement, false);\n  }\n\n  offset(hostElement: HTMLElement, targetElement: HTMLElement, round = true): Offsets {\n    return getReferenceOffsets(targetElement, hostElement);\n  }\n\n  positionElements(\n    hostElement: HTMLElement,\n    targetElement: HTMLElement,\n    position: string,\n    appendToBody?: boolean\n  ): Data {\n    const chainOfModifiers = [flip, shift, preventOverflow, arrow];\n\n    return chainOfModifiers.reduce(\n      (modifiedData, modifier) => modifier(modifiedData),\n      initData(targetElement, hostElement, position)\n    );\n  }\n}\n\nconst positionService = new Positioning();\n\nexport function positionElements(\n  hostElement: HTMLElement,\n  targetElement: HTMLElement,\n  placement: string,\n  appendToBody?: boolean,\n  renderer?: Renderer2\n): void {\n\n  const data = positionService.positionElements(\n    hostElement,\n    targetElement,\n    placement,\n    appendToBody\n  );\n\n  setAllStyles(data, renderer);\n}\n","import { Injectable, ElementRef, RendererFactory2 } from '@angular/core';\n\nimport { positionElements } from './ng-positioning';\nimport { fromEvent, merge, of, animationFrameScheduler, Subject } from 'rxjs';\n\n\nexport interface PositioningOptions {\n  /** The DOM element, ElementRef, or a selector string of an element which will be moved */\n  element?: HTMLElement | ElementRef | string;\n\n  /** The DOM element, ElementRef, or a selector string of an element which the element will be attached to  */\n  target?: HTMLElement | ElementRef | string;\n\n  /**\n   * A string of the form 'vert-attachment horiz-attachment' or 'placement'\n   * - placement can be \"top\", \"bottom\", \"left\", \"right\"\n   * not yet supported:\n   * - vert-attachment can be any of 'top', 'middle', 'bottom'\n   * - horiz-attachment can be any of 'left', 'center', 'right'\n   */\n  attachment?: string;\n\n  /** A string similar to `attachment`. The one difference is that, if it's not provided,\n   * `targetAttachment` will assume the mirror image of `attachment`.\n   */\n  targetAttachment?: string;\n\n  /** A string of the form 'vert-offset horiz-offset'\n   * - vert-offset and horiz-offset can be of the form \"20px\" or \"55%\"\n   */\n  offset?: string;\n\n  /** A string similar to `offset`, but referring to the offset of the target */\n  targetOffset?: string;\n\n  /** If true component will be attached to body */\n  appendToBody?: boolean;\n}\n\n\n@Injectable()\nexport class PositioningService {\n  private update$$ = new Subject<null>();\n\n  private events$: any = merge(\n    fromEvent(window, 'scroll'),\n    fromEvent(window, 'resize'),\n    of(0, animationFrameScheduler),\n    this.update$$\n  );\n\n  private positionElements = new Map();\n\n  constructor(rendererFactory: RendererFactory2) {\n    this.events$\n      .subscribe(() => {\n        this.positionElements\n          .forEach((positionElement: PositioningOptions) => {\n            positionElements(\n              _getHtmlElement(positionElement.target),\n              _getHtmlElement(positionElement.element),\n              positionElement.attachment,\n              positionElement.appendToBody,\n              rendererFactory.createRenderer(null, null)\n            );\n          });\n      });\n  }\n\n  position(options: PositioningOptions): void {\n    this.addPositionElement(options);\n    this.update$$.next();\n  }\n\n  addPositionElement(options: PositioningOptions): void {\n    this.positionElements.set(_getHtmlElement(options.element), options);\n  }\n\n  deletePositionElement(elRef: ElementRef): void {\n    this.positionElements.delete(_getHtmlElement(elRef));\n  }\n}\n\nfunction _getHtmlElement(element: HTMLElement | ElementRef | string): HTMLElement {\n  // it means that we got a selector\n  if (typeof element === 'string') {\n    return document.querySelector(element);\n  }\n\n  if (element instanceof ElementRef) {\n    return element.nativeElement;\n  }\n\n  return element;\n}\n"],"names":["runIsIE","setAllStyles","Subject","merge","fromEvent","of","animationFrameScheduler","Injectable","RendererFactory2","ElementRef"],"mappings":"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"}