Proyectos de Subversion Moodle

/**!

 * @fileOverview Kickass library to create and place poppers near their reference elements.

 * @version 1.12.6

 * @license

 * Copyright (c) 2016 Federico Zivolo and contributors

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

  typeof define === 'function' && define.amd ? define(factory) :

  (global.Popper = factory());

}(this, (function () { 'use strict';

var isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';

var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];

var timeoutDuration = 0;

for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {

  if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {

    timeoutDuration = 1;

    break;

  }

}

function microtaskDebounce(fn) {

  var called = false;

  return function () {

    if (called) {

      return;

    }

    called = true;

    Promise.resolve().then(function () {

      called = false;

      fn();

    });

  };

}

function taskDebounce(fn) {

  var scheduled = false;

  return function () {

    if (!scheduled) {

      scheduled = true;

      setTimeout(function () {

        scheduled = false;

        fn();

      }, timeoutDuration);

    }

  };

}

var supportsMicroTasks = isBrowser && window.Promise;

/**

* Create a debounced version of a method, that's asynchronously deferred

* but called in the minimum time possible.

*

* @method

* @memberof Popper.Utils

* @argument {Function} fn

* @returns {Function}

*/

var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;

/**

 * Check if the given variable is a function

 * @method

 * @memberof Popper.Utils

 * @argument {Any} functionToCheck - variable to check

 * @returns {Boolean} answer to: is a function?

 */

function isFunction(functionToCheck) {

  var getType = {};

  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';

}

/**

 * Get CSS computed property of the given element

 * @method

 * @memberof Popper.Utils

 * @argument {Eement} element

 * @argument {String} property

 */

function getStyleComputedProperty(element, property) {

  if (element.nodeType !== 1) {

    return [];

  }

  // NOTE: 1 DOM access here

  var css = window.getComputedStyle(element, null);

  return property ? css[property] : css;

}

/**

 * Returns the parentNode or the host of the element

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @returns {Element} parent

 */

function getParentNode(element) {

  if (element.nodeName === 'HTML') {

    return element;

  }

  return element.parentNode || element.host;

}

/**

 * Returns the scrolling parent of the given element

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @returns {Element} scroll parent

 */

function getScrollParent(element) {

  // Return body, `getScroll` will take care to get the correct `scrollTop` from it

  if (!element) {

    return window.document.body;

  }

  switch (element.nodeName) {

    case 'HTML':

    case 'BODY':

      return element.ownerDocument.body;

    case '#document':

      return element.body;

  }

  // Firefox want us to check `-x` and `-y` variations as well

  var _getStyleComputedProp = getStyleComputedProperty(element),

      overflow = _getStyleComputedProp.overflow,

      overflowX = _getStyleComputedProp.overflowX,

      overflowY = _getStyleComputedProp.overflowY;

  if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {

    return element;

  }

  return getScrollParent(getParentNode(element));

}

/**

 * Returns the offset parent of the given element

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @returns {Element} offset parent

 */

function getOffsetParent(element) {

  // NOTE: 1 DOM access here

  var offsetParent = element && element.offsetParent;

  var nodeName = offsetParent && offsetParent.nodeName;

  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {

    if (element) {

      return element.ownerDocument.documentElement;

    }

    return window.document.documentElement;

  }

  // .offsetParent will return the closest TD or TABLE in case

  // no offsetParent is present, I hate this job...

  if (['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {

    return getOffsetParent(offsetParent);

  }

  return offsetParent;

}

function isOffsetContainer(element) {

  var nodeName = element.nodeName;

  if (nodeName === 'BODY') {

    return false;

  }

  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;

}

/**

 * Finds the root node (document, shadowDOM root) of the given element

 * @method

 * @memberof Popper.Utils

 * @argument {Element} node

 * @returns {Element} root node

 */

function getRoot(node) {

  if (node.parentNode !== null) {

    return getRoot(node.parentNode);

  }

  return node;

}

/**

 * Finds the offset parent common to the two provided nodes

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element1

 * @argument {Element} element2

 * @returns {Element} common offset parent

 */

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 window.document.documentElement;

  }

  // Here we make sure to give as "start" the element that comes first in the DOM

  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;

  var start = order ? element1 : element2;

  var end = order ? element2 : element1;

  // Get common ancestor container

  var 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 element1root = getRoot(element1);

  if (element1root.host) {

    return findCommonOffsetParent(element1root.host, element2);

  } else {

    return findCommonOffsetParent(element1, getRoot(element2).host);

  }

}

/**

 * Gets the scroll value of the given element in the given side (top and left)

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @argument {String} side `top` or `left`

 * @returns {number} amount of scrolled pixels

 */

function getScroll(element) {

  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';

  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';

  var nodeName = element.nodeName;

  if (nodeName === 'BODY' || nodeName === 'HTML') {

    var html = element.ownerDocument.documentElement;

    var scrollingElement = element.ownerDocument.scrollingElement || html;

    return scrollingElement[upperSide];

  }

  return element[upperSide];

}

/*

 * Sum or subtract the element scroll values (left and top) from a given rect object

 * @method

 * @memberof Popper.Utils

 * @param {Object} rect - Rect object you want to change

 * @param {HTMLElement} element - The element from the function reads the scroll values

 * @param {Boolean} subtract - set to true if you want to subtract the scroll values

 * @return {Object} rect - The modifier rect object

 */

function includeScroll(rect, element) {

  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  var scrollTop = getScroll(element, 'top');

  var scrollLeft = getScroll(element, 'left');

  var modifier = subtract ? -1 : 1;

  rect.top += scrollTop * modifier;

  rect.bottom += scrollTop * modifier;

  rect.left += scrollLeft * modifier;

  rect.right += scrollLeft * modifier;

  return rect;

}

/*

 * Helper to detect borders of a given element

 * @method

 * @memberof Popper.Utils

 * @param {CSSStyleDeclaration} styles

 * Result of `getStyleComputedProperty` on the given element

 * @param {String} axis - `x` or `y`

 * @return {number} borders - The borders size of the given axis

 */

function getBordersSize(styles, axis) {

  var sideA = axis === 'x' ? 'Left' : 'Top';

  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';

  return +styles['border' + sideA + 'Width'].split('px')[0] + +styles['border' + sideB + 'Width'].split('px')[0];

}

/**

 * Tells if you are running Internet Explorer 10

 * @method

 * @memberof Popper.Utils

 * @returns {Boolean} isIE10

 */

var isIE10 = undefined;

var isIE10$1 = function () {

  if (isIE10 === undefined) {

    isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1;

  }

  return isIE10;

};

function getSize(axis, body, html, computedStyle) {

  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE10$1() ? html['offset' + axis] + computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')] + computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')] : 0);

}

function getWindowSizes() {

  var body = window.document.body;

  var html = window.document.documentElement;

  var computedStyle = isIE10$1() && window.getComputedStyle(html);

  return {

    height: getSize('Height', body, html, computedStyle),

    width: getSize('Width', body, html, computedStyle)

  };

}

var classCallCheck = function (instance, Constructor) {

  if (!(instance instanceof Constructor)) {

    throw new TypeError("Cannot call a class as a function");

  }

};

var createClass = function () {

  function defineProperties(target, props) {

    for (var i = 0; i < props.length; i++) {

      var descriptor = props[i];

      descriptor.enumerable = descriptor.enumerable || false;

      descriptor.configurable = true;

      if ("value" in descriptor) descriptor.writable = true;

      Object.defineProperty(target, descriptor.key, descriptor);

    }

  }

  return function (Constructor, protoProps, staticProps) {

    if (protoProps) defineProperties(Constructor.prototype, protoProps);

    if (staticProps) defineProperties(Constructor, staticProps);

    return Constructor;

  };

}();

var defineProperty = function (obj, key, value) {

  if (key in obj) {

    Object.defineProperty(obj, key, {

      value: value,

      enumerable: true,

      configurable: true,

      writable: true

    });

  } else {

    obj[key] = value;

  }

  return obj;

};

var _extends = Object.assign || function (target) {

  for (var i = 1; i < arguments.length; i++) {

    var source = arguments[i];

    for (var key in source) {

      if (Object.prototype.hasOwnProperty.call(source, key)) {

        target[key] = source[key];

      }

    }

  }

  return target;

};

/**

 * Given element offsets, generate an output similar to getBoundingClientRect

 * @method

 * @memberof Popper.Utils

 * @argument {Object} offsets

 * @returns {Object} ClientRect like output

 */

function getClientRect(offsets) {

  return _extends({}, offsets, {

    right: offsets.left + offsets.width,

    bottom: offsets.top + offsets.height

  });

}

/**

 * Get bounding client rect of given element

 * @method

 * @memberof Popper.Utils

 * @param {HTMLElement} element

 * @return {Object} client rect

 */

function getBoundingClientRect(element) {

  var 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

  if (isIE10$1()) {

    try {

      rect = element.getBoundingClientRect();

      var scrollTop = getScroll(element, 'top');

      var scrollLeft = getScroll(element, 'left');

      rect.top += scrollTop;

      rect.left += scrollLeft;

      rect.bottom += scrollTop;

      rect.right += scrollLeft;

    } catch (err) {}

  } else {

    rect = element.getBoundingClientRect();

  }

  var result = {

    left: rect.left,

    top: rect.top,

    width: rect.right - rect.left,

    height: rect.bottom - rect.top

  };

  // subtract scrollbar size from sizes

  var sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};

  var width = sizes.width || element.clientWidth || result.right - result.left;

  var height = sizes.height || element.clientHeight || result.bottom - result.top;

  var horizScrollbar = element.offsetWidth - width;

  var 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 styles = getStyleComputedProperty(element);

    horizScrollbar -= getBordersSize(styles, 'x');

    vertScrollbar -= getBordersSize(styles, 'y');

    result.width -= horizScrollbar;

    result.height -= vertScrollbar;

  }

  return getClientRect(result);

}

function getOffsetRectRelativeToArbitraryNode(children, parent) {

  var isIE10 = isIE10$1();

  var isHTML = parent.nodeName === 'HTML';

  var childrenRect = getBoundingClientRect(children);

  var parentRect = getBoundingClientRect(parent);

  var scrollParent = getScrollParent(children);

  var styles = getStyleComputedProperty(parent);

  var borderTopWidth = +styles.borderTopWidth.split('px')[0];

  var borderLeftWidth = +styles.borderLeftWidth.split('px')[0];

  var 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 marginTop = +styles.marginTop.split('px')[0];

    var marginLeft = +styles.marginLeft.split('px')[0];

    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 ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {

    offsets = includeScroll(offsets, parent);

  }

  return offsets;

}

function getViewportOffsetRectRelativeToArtbitraryNode(element) {

  var html = element.ownerDocument.documentElement;

  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);

  var width = Math.max(html.clientWidth, window.innerWidth || 0);

  var height = Math.max(html.clientHeight, window.innerHeight || 0);

  var scrollTop = getScroll(html);

  var scrollLeft = getScroll(html, 'left');

  var offset = {

    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,

    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,

    width: width,

    height: height

  };

  return getClientRect(offset);

}

/**

 * Check if the given element is fixed or is inside a fixed parent

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @argument {Element} customContainer

 * @returns {Boolean} answer to "isFixed?"

 */

function isFixed(element) {

  var nodeName = element.nodeName;

  if (nodeName === 'BODY' || nodeName === 'HTML') {

    return false;

  }

  if (getStyleComputedProperty(element, 'position') === 'fixed') {

    return true;

  }

  return isFixed(getParentNode(element));

}

/**

 * Computed the boundaries limits and return them

 * @method

 * @memberof Popper.Utils

 * @param {HTMLElement} popper

 * @param {HTMLElement} reference

 * @param {number} padding

 * @param {HTMLElement} boundariesElement - Element used to define the boundaries

 * @returns {Object} Coordinates of the boundaries

 */

function getBoundaries(popper, reference, padding, boundariesElement) {

  // NOTE: 1 DOM access here

  var boundaries = { top: 0, left: 0 };

  var offsetParent = findCommonOffsetParent(popper, reference);

  // Handle viewport case

  if (boundariesElement === 'viewport') {

    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent);

  } else {

    // Handle other cases based on DOM element used as boundaries

    var boundariesNode = void 0;

    if (boundariesElement === 'scrollParent') {

      boundariesNode = getScrollParent(getParentNode(popper));

      if (boundariesNode.nodeName === 'BODY') {

        boundariesNode = popper.ownerDocument.documentElement;

      }

    } else if (boundariesElement === 'window') {

      boundariesNode = popper.ownerDocument.documentElement;

    } else {

      boundariesNode = boundariesElement;

    }

    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent);

    // In case of HTML, we need a different computation

    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {

      var _getWindowSizes = getWindowSizes(),

          height = _getWindowSizes.height,

          width = _getWindowSizes.width;

      boundaries.top += offsets.top - offsets.marginTop;

      boundaries.bottom = height + offsets.top;

      boundaries.left += offsets.left - offsets.marginLeft;

      boundaries.right = width + 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;

}

function getArea(_ref) {

  var width = _ref.width,

      height = _ref.height;

  return width * height;

}

/**

 * Utility used to transform the `auto` placement to the placement with more

 * available space.

 * @method

 * @memberof Popper.Utils

 * @argument {Object} data - The data object generated by update method

 * @argument {Object} options - Modifiers configuration and options

 * @returns {Object} The data object, properly modified

 */

function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {

  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;

  if (placement.indexOf('auto') === -1) {

    return placement;

  }

  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);

  var 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 sortedAreas = Object.keys(rects).map(function (key) {

    return _extends({

      key: key

    }, rects[key], {

      area: getArea(rects[key])

    });

  }).sort(function (a, b) {

    return b.area - a.area;

  });

  var filteredAreas = sortedAreas.filter(function (_ref2) {

    var width = _ref2.width,

        height = _ref2.height;

    return width >= popper.clientWidth && height >= popper.clientHeight;

  });

  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;

  var variation = placement.split('-')[1];

  return computedPlacement + (variation ? '-' + variation : '');

}

/**

 * Get offsets to the reference element

 * @method

 * @memberof Popper.Utils

 * @param {Object} state

 * @param {Element} popper - the popper element

 * @param {Element} reference - the reference element (the popper will be relative to this)

 * @returns {Object} An object containing the offsets which will be applied to the popper

 */

function getReferenceOffsets(state, popper, reference) {

  var commonOffsetParent = findCommonOffsetParent(popper, reference);

  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent);

}

/**

 * Get the outer sizes of the given element (offset size + margins)

 * @method

 * @memberof Popper.Utils

 * @argument {Element} element

 * @returns {Object} object containing width and height properties

 */

function getOuterSizes(element) {

  var styles = window.getComputedStyle(element);

  var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);

  var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);

  var result = {

    width: element.offsetWidth + y,

    height: element.offsetHeight + x

  };

  return result;

}

/**

 * Get the opposite placement of the given one

 * @method

 * @memberof Popper.Utils

 * @argument {String} placement

 * @returns {String} flipped placement

 */

function getOppositePlacement(placement) {

  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };

  return placement.replace(/left|right|bottom|top/g, function (matched) {

    return hash[matched];

  });

}

/**

 * Get offsets to the popper

 * @method

 * @memberof Popper.Utils

 * @param {Object} position - CSS position the Popper will get applied

 * @param {HTMLElement} popper - the popper element

 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)

 * @param {String} placement - one of the valid placement options

 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper

 */

function getPopperOffsets(popper, referenceOffsets, placement) {

  placement = placement.split('-')[0];

  // Get popper node sizes

  var popperRect = getOuterSizes(popper);

  // Add position, width and height to our offsets object

  var popperOffsets = {

    width: popperRect.width,

    height: popperRect.height

  };

  // depending by the popper placement we have to compute its offsets slightly differently

  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;

  var mainSide = isHoriz ? 'top' : 'left';

  var secondarySide = isHoriz ? 'left' : 'top';

  var measurement = isHoriz ? 'height' : 'width';

  var secondaryMeasurement = !isHoriz ? 'height' : 'width';

  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;

  if (placement === secondarySide) {

    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];

  } else {

    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];

  }

  return popperOffsets;

}

/**

 * Mimics the `find` method of Array

 * @method

 * @memberof Popper.Utils

 * @argument {Array} arr

 * @argument prop

 * @argument value

 * @returns index or -1

 */

function find(arr, check) {

  // use native find if supported

  if (Array.prototype.find) {

    return arr.find(check);

  }

  // use `filter` to obtain the same behavior of `find`

  return arr.filter(check)[0];

}

/**

 * Return the index of the matching object

 * @method

 * @memberof Popper.Utils

 * @argument {Array} arr

 * @argument prop

 * @argument value

 * @returns index or -1

 */

function findIndex(arr, prop, value) {

  // use native findIndex if supported

  if (Array.prototype.findIndex) {

    return arr.findIndex(function (cur) {

      return cur[prop] === value;

    });

  }

  // use `find` + `indexOf` if `findIndex` isn't supported

  var match = find(arr, function (obj) {

    return obj[prop] === value;

  });

  return arr.indexOf(match);

}

/**

 * Loop trough the list of modifiers and run them in order,

 * each of them will then edit the data object.

 * @method

 * @memberof Popper.Utils

 * @param {dataObject} data

 * @param {Array} modifiers

 * @param {String} ends - Optional modifier name used as stopper

 * @returns {dataObject}

 */

function runModifiers(modifiers, data, ends) {

  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));

  modifiersToRun.forEach(function (modifier) {

    if (modifier['function']) {

      // eslint-disable-line dot-notation

      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');

    }

    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation

    if (modifier.enabled && isFunction(fn)) {

      // Add properties to offsets to make them a complete clientRect object

      // we do this before each modifier to make sure the previous one doesn't

      // mess with these values

      data.offsets.popper = getClientRect(data.offsets.popper);

      data.offsets.reference = getClientRect(data.offsets.reference);

      data = fn(data, modifier);

    }

  });

  return data;

}

/**

 * Updates the position of the popper, computing the new offsets and applying

 * the new style.<br />

 * Prefer `scheduleUpdate` over `update` because of performance reasons.

 * @method

 * @memberof Popper

 */

function update() {

  // if popper is destroyed, don't perform any further update

  if (this.state.isDestroyed) {

    return;

  }

  var data = {

    instance: this,

    styles: {},

    arrowStyles: {},

    attributes: {},

    flipped: false,

    offsets: {}

  };

  // compute reference element offsets

  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference);

  // compute auto placement, store placement inside the data object,

  // modifiers will be able to edit `placement` if needed

  // and refer to originalPlacement to know the original value

  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);

  // store the computed placement inside `originalPlacement`

  data.originalPlacement = data.placement;

  // compute the popper offsets

  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);

  data.offsets.popper.position = 'absolute';

  // run the modifiers

  data = runModifiers(this.modifiers, data);

  // the first `update` will call `onCreate` callback

  // the other ones will call `onUpdate` callback

  if (!this.state.isCreated) {

    this.state.isCreated = true;

    this.options.onCreate(data);

  } else {

    this.options.onUpdate(data);

  }

}

/**

 * Helper used to know if the given modifier is enabled.

 * @method

 * @memberof Popper.Utils

 * @returns {Boolean}

 */

function isModifierEnabled(modifiers, modifierName) {

  return modifiers.some(function (_ref) {

    var name = _ref.name,

        enabled = _ref.enabled;

    return enabled && name === modifierName;

  });

}

/**

 * Get the prefixed supported property name

 * @method

 * @memberof Popper.Utils

 * @argument {String} property (camelCase)

 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)

 */

function getSupportedPropertyName(property) {

  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];

  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);

  for (var i = 0; i < prefixes.length - 1; i++) {

    var prefix = prefixes[i];

    var toCheck = prefix ? '' + prefix + upperProp : property;

    if (typeof window.document.body.style[toCheck] !== 'undefined') {

      return toCheck;

    }

  }

  return null;

}

/**

 * Destroy the popper

 * @method

 * @memberof Popper

 */

function destroy() {

  this.state.isDestroyed = true;

  // touch DOM only if `applyStyle` modifier is enabled

  if (isModifierEnabled(this.modifiers, 'applyStyle')) {

    this.popper.removeAttribute('x-placement');

    this.popper.style.left = '';

    this.popper.style.position = '';

    this.popper.style.top = '';

    this.popper.style[getSupportedPropertyName('transform')] = '';

  }

  this.disableEventListeners();

  // remove the popper if user explicity asked for the deletion on destroy

  // do not use `remove` because IE11 doesn't support it

  if (this.options.removeOnDestroy) {

    this.popper.parentNode.removeChild(this.popper);

  }

  return this;

}

/**

 * Get the window associated with the element

 * @argument {Element} element

 * @returns {Window}

 */

function getWindow(element) {

  var ownerDocument = element.ownerDocument;

  return ownerDocument ? ownerDocument.defaultView : window;

}

function attachToScrollParents(scrollParent, event, callback, scrollParents) {

  var isBody = scrollParent.nodeName === 'BODY';

  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;

  target.addEventListener(event, callback, { passive: true });

  if (!isBody) {

    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);

  }

  scrollParents.push(target);

}

/**

 * Setup needed event listeners used to update the popper position

 * @method

 * @memberof Popper.Utils

 * @private

 */

function setupEventListeners(reference, options, state, updateBound) {

  // Resize event listener on window

  state.updateBound = updateBound;

  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });

  // Scroll event listener on scroll parents

  var scrollElement = getScrollParent(reference);

  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);

  state.scrollElement = scrollElement;

  state.eventsEnabled = true;

  return state;

}

/**

 * It will add resize/scroll events and start recalculating

 * position of the popper element when they are triggered.

 * @method

 * @memberof Popper

 */

function enableEventListeners() {

  if (!this.state.eventsEnabled) {