https://www.illumina.com/etc.clientlibs/illumina-designs/illumina-…-center.69c0ccf1eca025d4ff7d4b5440dd342e.js

290/**
291 * Get CSS computed property of the given element
292 * @method
293 * @memberof Popper.Utils
294 * @argument {Eement} element
295 * @argument {String} property
296 */
297function getStyleComputedProperty(element, property) {
298  if (element.nodeType !== 1) {
299    return [];
300  }
301  // NOTE: 1 DOM access here
302  var window = element.ownerDocument.defaultView;
303  var css = window.getComputedStyle(element, null);
304  return property ? css[property] : css;
305}
306
307/**
308 * Returns the parentNode or the host of the element
309 * @method
310 * @memberof Popper.Utils
311 * @argument {Element} element
312 * @returns {Element} parent
313 */
314function getParentNode(element) {
315  if (element.nodeName === 'HTML') {
316    return element;
317  }
318  return element.parentNode || element.host;
319}
320
321/**
322 * Returns the scrolling parent of the given element
323 * @method
324 * @memberof Popper.Utils
325 * @argument {Element} element
326 * @returns {Element} scroll parent
327 */
328function getScrollParent(element) {
329  // Return body, `getScroll` will take care to get the correct `scrollTop` from it
330  if (!element) {
331    return document.body;
332  }
333
334  switch (element.nodeName) {
335    case 'HTML':
336    case 'BODY':
337      return element.ownerDocument.body;
338    case '#document':
339      return element.body;
340  }
341
342  // Firefox want us to check `-x` and `-y` variations as well
343
344  var _getStyleComputedProp = getStyleComputedProperty(element),
345      overflow = _getStyleComputedProp.overflow,
346      overflowX = _getStyleComputedProp.overflowX,
347      overflowY = _getStyleComputedProp.overflowY;
348
349  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
350    return element;
351  }
352
353  return getScrollParent(getParentNode(element));
354}
355
356/**
357 * Returns the reference node of the reference object, or the reference object itself.
358 * @method
359 * @memberof Popper.Utils
360 * @param {Element|Object} reference - the reference element (the popper will be relative to this)
361 * @returns {Element} parent
362 */
363function getReferenceNode(reference) {
364  return reference && reference.referenceNode ? reference.referenceNode : reference;
365}
366
367var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
368var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
369
370/**
371 * Determines if the browser is Internet Explorer
372 * @method
373 * @memberof Popper.Utils
374 * @param {Number} version to check
375 * @returns {Boolean} isIE
376 */
377function isIE(version) {
378  if (version === 11) {
379    return isIE11;
380  }
381  if (version === 10) {
382    return isIE10;
383  }
384  return isIE11 || isIE10;
385}
386
387/**
388 * Returns the offset parent of the given element
389 * @method
390 * @memberof Popper.Utils
391 * @argument {Element} element
392 * @returns {Element} offset parent
393 */
394function getOffsetParent(element) {
395  if (!element) {
396    return document.documentElement;
397  }
398
399  var noOffsetParent = isIE(10) ? document.body : null;
400
401  // NOTE: 1 DOM access here
402  var offsetParent = element.offsetParent || null;
403  // Skip hidden elements which don't have an offsetParent
404  while (offsetParent === noOffsetParent && element.nextElementSibling) {
405    offsetParent = (element = element.nextElementSibling).offsetParent;
406  }
407
408  var nodeName = offsetParent && offsetParent.nodeName;
409
410  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
411    return element ? element.ownerDocument.documentElement : document.documentElement;
412  }
413
414  // .offsetParent will return the closest TH, TD or TABLE in case
415  // no offsetParent is present, I hate this job...
416  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
417    return getOffsetParent(offsetParent);
418  }
419
420  return offsetParent;
421}
422
423function isOffsetContainer(element) {
424  var nodeName = element.nodeName;
425
426  if (nodeName === 'BODY') {
427    return false;
428  }
429  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
430}
431
432/**
433 * Finds the root node (document, shadowDOM root) of the given element
434 * @method
435 * @memberof Popper.Utils
436 * @argument {Element} node
437 * @returns {Element} root node
438 */
439function getRoot(node) {
440  if (node.parentNode !== null) {
441    return getRoot(node.parentNode);
442  }
443
444  return node;
445}
446
447/**
448 * Finds the offset parent common to the two provided nodes
449 * @method
450 * @memberof Popper.Utils
451 * @argument {Element} element1
452 * @argument {Element} element2
453 * @returns {Element} common offset parent
454 */
455function findCommonOffsetParent(element1, element2) {
456  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
457  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
458    return document.documentElement;
459  }
460
461  // Here we make sure to give as "start" the element that comes first in the DOM
462  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
463  var start = order ? element1 : element2;
464  var end = order ? element2 : element1;
465
466  // Get common ancestor container
467  var range = document.createRange();
468  range.setStart(start, 0);
469  range.setEnd(end, 0);
470  var commonAncestorContainer = range.commonAncestorContainer;
471
472  // Both nodes are inside #document
473
474  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
475    if (isOffsetContainer(commonAncestorContainer)) {
476      return commonAncestorContainer;
477    }
478
479    return getOffsetParent(commonAncestorContainer);
480  }
481
482  // one of the nodes is inside shadowDOM, find which one
483  var element1root = getRoot(element1);
484  if (element1root.host) {
485    return findCommonOffsetParent(element1root.host, element2);
486  } else {
487    return findCommonOffsetParent(element1, getRoot(element2).host);
488  }
489}
490
491/**
492 * Gets the scroll value of the given element in the given side (top and left)
493 * @method
494 * @memberof Popper.Utils
495 * @argument {Element} element
496 * @argument {String} side `top` or `left`
497 * @returns {number} amount of scrolled pixels
498 */
499function getScroll(element) {
500  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
501
502  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
503  var nodeName = element.nodeName;
504
505  if (nodeName === 'BODY' || nodeName === 'HTML') {
506    var html = element.ownerDocument.documentElement;
507    var scrollingElement = element.ownerDocument.scrollingElement || html;
508    return scrollingElement[upperSide];
509  }
510
511  return element[upperSide];
512}
513
514/*
515 * Sum or subtract the element scroll values (left and top) from a given rect object
516 * @method
517 * @memberof Popper.Utils
518 * @param {Object} rect - Rect object you want to change
519 * @param {HTMLElement} element - The element from the function reads the scroll values
520 * @param {Boolean} subtract - set to true if you want to subtract the scroll values
521 * @return {Object} rect - The modifier rect object
522 */
523function includeScroll(rect, element) {
524  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
525
526  var scrollTop = getScroll(element, 'top');
527  var scrollLeft = getScroll(element, 'left');
528  var modifier = subtract ? -1 : 1;
529  rect.top += scrollTop * modifier;
530  rect.bottom += scrollTop * modifier;
531  rect.left += scrollLeft * modifier;
532  rect.right += scrollLeft * modifier;
533  return rect;
534}
535
536/*
537 * Helper to detect borders of a given element
538 * @method
539 * @memberof Popper.Utils
540 * @param {CSSStyleDeclaration} styles
541 * Result of `getStyleComputedProperty` on the given element
542 * @param {String} axis - `x` or `y`
543 * @return {number} borders - The borders size of the given axis
544 */
545
546function getBordersSize(styles, axis) {
547  var sideA = axis === 'x' ? 'Left' : 'Top';
548  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
549
550  return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
551}
552
553function getSize(axis, body, html, computedStyle) {
554  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
555}
556
557function getWindowSizes(document) {
558  var body = document.body;
559  var html = document.documentElement;
560  var computedStyle = isIE(10) && getComputedStyle(html);
561
562  return {
563    height: getSize('Height', body, html, computedStyle),
564    width: getSize('Width', body, html, computedStyle)
565  };
566}
567
568var classCallCheck = function (instance, Constructor) {
569  if (!(instance instanceof Constructor)) {
570    throw new TypeError("Cannot call a class as a function");
571  }
572};
573
574var createClass = function () {
575  function defineProperties(target, props) {
576    for (var i = 0; i < props.length; i++) {
577      var descriptor = props[i];
578      descriptor.enumerable = descriptor.enumerable || false;
579      descriptor.configurable = true;
580      if ("value" in descriptor) descriptor.writable = true;
581      Object.defineProperty(target, descriptor.key, descriptor);
582    }
583  }
584
585  return function (Constructor, protoProps, staticProps) {
586    if (protoProps) defineProperties(Constructor.prototype, protoProps);
587    if (staticProps) defineProperties(Constructor, staticProps);
588    return Constructor;
589  };
590}();
591
592
593
594
595
596var defineProperty = function (obj, key, value) {
597  if (key in obj) {
598    Object.defineProperty(obj, key, {
599      value: value,
600      enumerable: true,
601      configurable: true,
602      writable: true
603    });
604  } else {
605    obj[key] = value;
606  }
607
608  return obj;
609};
610
611var _extends = Object.assign || function (target) {
612  for (var i = 1; i < arguments.length; i++) {
613    var source = arguments[i];
614
615    for (var key in source) {
616      if (Object.prototype.hasOwnProperty.call(source, key)) {
617        target[key] = source[key];
618      }
619    }
620  }
621
622  return target;
623};
624
625/**
626 * Given element offsets, generate an output similar to getBoundingClientRect
627 * @method
628 * @memberof Popper.Utils
629 * @argument {Object} offsets
630 * @returns {Object} ClientRect like output
631 */
632function getClientRect(offsets) {
633  return _extends({}, offsets, {
634    right: offsets.left + offsets.width,
635    bottom: offsets.top + offsets.height
636  });
637}
638
639/**
640 * Get bounding client rect of given element
641 * @method
642 * @memberof Popper.Utils
643 * @param {HTMLElement} element
644 * @return {Object} client rect
645 */
646function getBoundingClientRect(element) {
647  var rect = {};
648
649  // IE10 10 FIX: Please, don't ask, the element isn't

650  // considered in DOM in some circumstances...
651  // This isn't reproducible in IE10 compatibility mode of IE11
652  try {
653    if (isIE(10)) {
654      rect = element.getBoundingClientRect();
655      var scrollTop = getScroll(element, 'top');
656      var scrollLeft = getScroll(element, 'left');
657      rect.top += scrollTop;
658      rect.left += scrollLeft;
659      rect.bottom += scrollTop;
660      rect.right += scrollLeft;
661    } else {
662      rect = element.getBoundingClientRect();
663    }
664  } catch (e) {}
665
666  var result = {
667    left: rect.left,
668    top: rect.top,
669    width: rect.right - rect.left,
670    height: rect.bottom - rect.top
671  };
672
673  // subtract scrollbar size from sizes
674  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
675  var width = sizes.width || element.clientWidth || result.width;
676  var height = sizes.height || element.clientHeight || result.height;
677
678  var horizScrollbar = element.offsetWidth - width;
679  var vertScrollbar = element.offsetHeight - height;
680
681  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
682  // we make this check conditional for performance reasons
683  if (horizScrollbar || vertScrollbar) {
684    var styles = getStyleComputedProperty(element);
685    horizScrollbar -= getBordersSize(styles, 'x');
686    vertScrollbar -= getBordersSize(styles, 'y');
687
688    result.width -= horizScrollbar;
689    result.height -= vertScrollbar;
690  }
691
692  return getClientRect(result);
693}
694
695function getOffsetRectRelativeToArbitraryNode(children, parent) {
696  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
697
698  var isIE10 = isIE(10);
699  var isHTML = parent.nodeName === 'HTML';
700  var childrenRect = getBoundingClientRect(children);
701  var parentRect = getBoundingClientRect(parent);
702  var scrollParent = getScrollParent(children);
703
704  var styles = getStyleComputedProperty(parent);
705  var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
706  var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
707
708  // In cases where the parent is fixed, we must ignore negative scroll in offset calc
709  if (fixedPosition && isHTML) {
710    parentRect.top = Math.max(parentRect.top, 0);
711    parentRect.left = Math.max(parentRect.left, 0);
712  }
713  var offsets = getClientRect({
714    top: childrenRect.top - parentRect.top - borderTopWidth,
715    left: childrenRect.left - parentRect.left - borderLeftWidth,
716    width: childrenRect.width,
717    height: childrenRect.height
718  });
719  offsets.marginTop = 0;
720  offsets.marginLeft = 0;
721
722  // Subtract margins of documentElement in case it's being used as parent
723  // we do this only on HTML because it's the only element that behaves
724  // differently when margins are applied to it. The margins are included in
725  // the box of the documentElement, in the other cases not.
726  if (!isIE10 && isHTML) {
727    var marginTop = parseFloat(styles.marginTop, 10);
728    var marginLeft = parseFloat(styles.marginLeft, 10

728);
729
730    offsets.top -= borderTopWidth - marginTop;
731    offsets.bottom -= borderTopWidth - marginTop;
732    offsets.left -= borderLeftWidth - marginLeft;
733    offsets.right -= borderLeftWidth - marginLeft;
734
735    // Attach marginTop and marginLeft because in some circumstances we may need them
736    offsets.marginTop = marginTop;
737    offsets.marginLeft = marginLeft;
738  }
739
740  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
741    offsets = includeScroll(offsets, parent);
742  }
743
744  return offsets;
745}
746
747function getViewportOffsetRectRelativeToArtbitraryNode(element) {
748  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
749
750  var html = element.ownerDocument.documentElement;
751  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
752  var width = Math.max(html.clientWidth, window.innerWidth || 0);
753  var height = Math.max(html.clientHeight, window.innerHeight || 0);
754
755  var scrollTop = !excludeScroll ? getScroll(html) : 0;
756  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
757
758  var offset = {
759    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
760    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
761    width: width,
762    height: height
763  };
764
765  return getClientRect(offset);
766}
767
768/**
769 * Check if the given element is fixed or is inside a fixed parent
770 * @method
771 * @memberof Popper.Utils
772 * @argument {Element} element
773 * @argument {Element} customContainer
774 * @returns {Boolean} answer to "isFixed?"
775 */
776function isFixed(element) {
777  var nodeName = element.nodeName;
778  if (nodeName === 'BODY' || nodeName === 'HTML') {
779    return false;
780  }
781  if (getStyleComputedProperty(element, 'position') === 'fixed') {
782    return true;
783  }
784  var parentNode = getParentNode(element);
785  if (!parentNode) {
786    return false;
787  }
788  return isFixed(parentNode);
789}
790
791/**
792 * Finds the first parent of an element that has a transformed property defined
793 * @method
794 * @memberof Popper.Utils
795 * @argument {Element} element
796 * @returns {Element} first transformed parent or documentElement
797 */
798
799function getFixedPositionOffsetParent(element) {
800  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
801  if (!element || !element.parentElement || isIE()) {
802    return document.documentElement;
803  }
804  var el = element.parentElement;
805  while (el && getStyleComputedProperty(el, 'transform') === 'none') {
806    el = el.parentElement;
807  }
808  return el || document.documentElement;
809}
810
811/**
812 * Computed the boundaries limits and return them
813 * @method
814 * @memberof Popper.Utils
815 * @param {HTMLElement} popper
816 * @param {HTMLElement} reference
817 * @param {number} padding
818 * @param {HTMLElement} boundariesElement - Element used to define the boundaries
819 * @param {Boolean} fixedPosition - Is in fixed position mode
820 * @returns {Object} Coordinates of the boundaries
821 */
822function getBoundaries(popper, reference, padding, boundariesElement) {
823  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
824
825  // NOTE: 1 DOM access here
826
827  var boundaries = { top: 0, left: 0 };
828  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
829
830  // Handle viewport case
831  if (boundariesElement === 'viewport') {
832    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
833  } else {
834    // Handle other cases based on DOM element used as boundaries
835    var boundariesNode = void 0;
836    if (boundariesElement === 'scrollParent') {
837      boundariesNode = getScrollParent(getParentNode(reference));
838      if (boundariesNode.nodeName === 'BODY') {
839        boundariesNode = popper.ownerDocument.documentElement;
840      }
841    } else if (boundariesElement === 'window') {
842      boundariesNode = popper.ownerDocument.documentElement;
843    } else {
844      boundariesNode = boundariesElement;
845    }
846
847    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
848
849    // In case of HTML, we need a different computation
850    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
851      var _getWindowSizes = getWindowSizes(popper.ownerDocument),
852          height = _getWindowSizes.height,
853          width = _getWindowSizes.width;
854
855      boundaries.top += offsets.top - offsets.marginTop;
856      boundaries.bottom = height + offsets.top;
857      boundaries.left += offsets.left - offsets.marginLeft;
858      boundaries.right = width + offsets.left;
859    } else {
860      // for all the other DOM elements, this one is good
861      boundaries = offsets;
862    }
863  }
864
865  // Add paddings
866  padding = padding || 0;
867  var isPaddingNumber = typeof padding === 'number';
868  boundaries.left += isPaddingNumber ? padding : padding.left || 0;
869  boundaries.top += isPaddingNumber ? padding : padding.top || 0;
870  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
871  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
872
873  return boundaries;
874}
875
876function getArea(_ref) {
877  var width = _ref.width,
878      height = _ref.height;
879
880  return width * height;
881}
882
883/**
884 * Utility used to transform the `auto` placement to the placement with more
885 * available space.
886 * @method
887 * @memberof Popper.Utils
888 * @argument {Object} data - The data object generated by update method
889 * @argument {Object} options - Modifiers configuration and options
890 * @returns {Object} The data object, properly modified
891 */
892function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
893  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
894
895  if (placement.indexOf('auto') === -1) {
896    return placement;
897  }
898
899  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
900
901  var rects = {
902    top: {
903      width: boundaries.width,
904      height: refRect.top - boundaries.top
905    },
906    right: {
907      width: boundaries.right - refRect.right,
908      height: boundaries.height
909    },
910    bottom: {
911      width: boundaries.width,
912      height: boundaries.bottom - refRect.bottom
913    },
914    left: {
915      width: refRect.left - boundaries.left,
916      height: boundaries.height
917    }
918  };
919
920  var sortedAreas = Object.keys(rects).map(function (key) {
921    return _extends({
922      key: key
923    }, rects[key], {
924      area: getArea(rects[key])
925    });
926  }).sort(function (a, b) {
927    return b.area - a.area;
928  });
929
930  var filteredAreas = sortedAreas.filter(function (_ref2) {
931    var width = _ref2.width,
932        height = _ref2.height;
933    return width >= popper.clientWidth && height >= popper.clientHeight;
934  });
935
936  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
937
938  var variation = placement.split('-')[1];
939
940  return computedPlacement + (variation ? '-' + variation : '');
941}
942
943/**
944 * Get offsets to the reference element
945 * @method
946 * @memberof Popper.Utils
947 * @param {Object} state
948 * @param {Element} popper - the popper element
949 * @param {Element} reference - the reference element (the popper will be relative to this)
950 * @param {Element} fixedPosition - is in fixed position mode
951 * @returns {Object} An object containing the offsets which will be applied to the popper
952 */
953function getReferenceOffsets(state, popper, reference) {
954  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
955
956  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
957  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
958}
959
960/**
961 * Get the outer sizes of the given element (offset size + margins)
962 * @method
963 * @memberof Popper.Utils
964 * @argument {Element} element
965 * @returns {Object} object containing width and height properties
966 */
967function getOuterSizes(element) {
968  var window = element.ownerDocument.defaultView;
969  var styles = window.getComputedStyle(element);
970  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
971  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
972  var result = {
973    width: element.offsetWidth + y,
974    height: element.offsetHeight + x
975  };
976  return result;
977}
978
979/**
980 * Get the opposite placement of the given one
981 * @method
982 * @memberof Popper.Utils
983 * @argument {String} placement
984 * @returns {String} flipped placement
985 */
986function getOppositePlacement(placement) {
987  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
988  return placement.replace(/left|right|bottom|top/g, function (matched) {
989    return hash[matched];
990  });
991}
992
993/**
994 * Get offsets to the popper
995 * @method
996 * @memberof Popper.Utils
997 * @param {Object} position - CSS position the Popper will get applied
998 * @param {HTMLElement} popper - the popper element
999 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
1000 * @param {String} placement - one of the valid placement options
1001 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
1002 */
1003function getPopperOffsets(popper, referenceOffsets, placement) {
1004  placement = placement.split('-')[0];
1005
1006  // Get popper node sizes
1007  var popperRect = getOuterSizes(popper);
1008
1009  // Add position, width and height to our offsets object
1010  var popperOffsets = {
1011    width: popperRect.width,
1012    height: popperRect.height
1013  };
1014
1015  // depending by the popper placement we have to compute its offsets slightly differently
1016  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
1017  var mainSide = isHoriz ? 'top' : 'left';
1018  var secondarySide = isHoriz ? 'left' : 'top';
1019  var measurement = isHoriz ? 'height' : 'width';
1020  var secondaryMeasurement = !isHoriz ? 'height' : 'width';
1021
1022  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
1023  if (placement === secondarySide) {
1024    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
1025  } else {
1026    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
1027  }
1028
1029  return popperOffsets;
1030}
1031
1032/**
1033 * Mimics the `find` method of Array
1034 * @method
1035 * @memberof Popper.Utils
1036 * @argument {Array} arr
1037 * @argument prop
1038 * @argument value
1039 * @returns index or -1
1040 */
1041function find(arr, check) {
1042  // use native find if supported
1043  if (Array.prototype.find) {
1044    return arr.find(check);
1045  }
1046
1047  // use `filter` to obtain the same behavior of `find`
1048  return arr.filter(check)[0];
1049}
1050
1051/**
1052 * Return the index of the matching object
1053 * @method
1054 * @memberof Popper.Utils
1055 * @argument {Array} arr
1056 * @argument prop
1057 * @argument value
1058 * @returns index or -1
1059 */
1060function findIndex(arr, prop, value) {
1061  // use native findIndex if supported
1062  if (Array.prototype.findIndex) {
1063    return arr.findIndex(function (cur) {
1064      return cur[prop] === value;
1065    });
1066  }
1067
1068  // use `find` + `indexOf` if `findIndex` isn't supported
1069  var match = find(arr, function (obj) {
1070    return obj[prop] === value;
1071  });
1072  return arr.indexOf(match);
1073}
1074
1075/**
1076 * Loop trough the list of modifiers and run them in order,
1077 * each of them will then edit the data object.
1078 * @method
1079 * @memberof Popper.Utils
1080 * @param {dataObject} data
1081 * @param {Array} modifiers
1082 * @param {String} ends - Optional modifier name used as stopper
1083 * @returns {dataObject}
1084 */
1085function runModifiers(modifiers, data, ends) {
1086  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
1087
1088  modifiersToRun.forEach(function (modifier) {
1089    if (modifier['function']) {
1090      // eslint-disable-line dot-notation
1091      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
1092    }
1093    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
1094    if (modifier.enabled && isFunction(fn)) {
1095      // Add properties to offsets to make them a complete clientRect object
1096      // we do this before each modifier to make sure the previous one doesn't
1097      // mess with these values
1098      data.offsets.popper = getClientRect(data.offsets.popper);
1099      data.offsets.reference = getClientRect(data.offsets.reference);
1100
1101      data = fn(data, modifier);
1102    }
1103  });
1104
1105  return data;
1106}
1107
1108/**
1109 * Updates the position of the popper, computing the new offsets and applying
1110 * the new style.<br />
1111 * Prefer `scheduleUpdate` over `update` because of performance reasons.
1112 * @method
1113 * @memberof Popper
1114 */
1115function update() {
1116  // if popper is destroyed, don't perform any further update
1117  if (this.state.isDestroyed) {
1118    return;
1119  }
1120
1121  var data = {
1122    instance: this,
1123    styles: {},
1124    arrowStyles: {},
1125    attributes: {},
1126    flipped: false,
1127    offsets: {}
1128  };
1129
1130  // compute reference element offsets
1131  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
1132
1133  // compute auto placement, store placement inside the data object,
1134  // modifiers will be able to edit `placement` if needed
1135  // and refer to originalPlacement to know the original value
1136  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
1137
1138  // store the computed placement inside `originalPlacement`
1139  data.originalPlacement = data.placement;
1140
1141  data.positionFixed = this.options.positionFixed;
1142
1143  // compute the popper offsets
1144  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
1145
1146  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
1147
1148  // run the modifiers
1149  data = runModifiers(this.modifiers, data);
1150
1151  // the first `update` will call `onCreate` callback
1152  // the other ones will call `onUpdate` callback
1153  if (!this.state.isCreated) {
1154    this.state.isCreated = true;
1155    this.options.onCreate(data);
1156  } else {
1157    this.options.onUpdate(data);
1158  }
1159}
1160
1161/**
1162 * Helper used to know if the given modifier is enabled.
1163 * @method
1164 * @memberof Popper.Utils
1165 * @returns {Boolean}
1166 */
1167function isModifierEnabled(modifiers, modifierName) {
1168  return modifiers.some(function (_ref) {
1169    var name = _ref.name,
1170        enabled = _ref.enabled;
1171    return enabled && name === modifierName;
1172  });
1173}
1174
1175/**
1176 * Get the prefixed supported property name
1177 * @method
1178 * @memberof Popper.Utils
1179 * @argument {String} property (camelCase)
1180 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
1181 */
1182function getSupportedPropertyName(property) {
1183  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
1184  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
1185
1186  for (var i = 0; i < prefixes.length; i++) {
1187    var prefix = prefixes[i];
1188    var toCheck = prefix ? '' + prefix + upperProp : property;
1189    if (typeof document.body.style[toCheck] !== 'undefined') {
1190      return toCheck;
1191    }
1192  }
1193  return null;
1194}
1195
1196/**
1197 * Destroys the popper.
1198 * @method
1199 * @memberof Popper
1200 */
1201function destroy() {
1202  this.state.isDestroyed = true;
1203
1204  // touch DOM only if `applyStyle` modifier is enabled
1205  if (isModifierEnabled(this.modifiers, 'applyStyle')) {
1206    this.popper.removeAttribute('x-placement');
1207    this.popper.style.position = '';
1208    this.popper.style.top = '';
1209    this.popper.style.left = '';
1210    this.popper.style.right = '';
1211    this.popper.style.bottom = '';
1212    this.popper.style.willChange = '';
1213    this.popper.style[getSupportedPropertyName('transform')] = '';
1214  }
1215
1216  this.disableEventListeners();
1217
1218  // remove the popper if user explicitly asked for the deletion on destroy
1219  // do not use `remove` because IE11 doesn't support it
1220  if (this.options.removeOnDestroy) {
1221    this.popper.parentNode.removeChild(this.popper);
1222  }
1223  return this;
1224}
1225
1226/**
1227 * Get the window associated with the element
1228 * @argument {Element} element
1229 * @returns {Window}
1230 */
1231function getWindow(element) {
1232  var ownerDocument = element.ownerDocument;
1233  return ownerDocument ? ownerDocument.defaultView : window;
1234}
1235
1236function attachToScrollParents(scrollParent, event, callback, scrollParents) {
1237  var isBody = scrollParent.nodeName === 'BODY';
1238  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
1239  target.addEventListener(event, callback, { passive: true });
1240
1241  if (!isBody) {
1242    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
1243  }
1244  scrollParents.push(target);
1245}
1246
1247/**
1248 * Setup needed event listeners used to update the popper position
1249 * @method
1250 * @memberof Popper.Utils
1251 * @private
1252 */
1253function setupEventListeners(reference, options, state, updateBound) {
1254  // Resize event listener on window
1255  state.updateBound = updateBound;
1256  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
1257
1258  // Scroll event listener on scroll parents
1259  var scrollElement = getScrollParent(reference);
1260  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
1261  state.scrollElement = scrollElement;
1262  state.eventsEnabled = true;
1263
1264  return state;
1265}
1266
1267/**
1268 * It will add resize/scroll events and start recalculating
1269 * position of the popper element when they are triggered.
1270 * @method
1271 * @memberof Popper
1272 */
1273function enableEventListeners() {
1274  if (!this.state.eventsEnabled) {
1275    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
1276  }
1277}
1278
1279/**
1280 * Remove event listeners used to update the popper position
1281 * @method
1282 * @memberof Popper.Utils
1283 * @private
1284 */
1285function removeEventListeners(reference, state) {
1286  // Remove resize event listener on window
1287  getWindow(reference).removeEventListener('resize', state.updateBound);
1288
1289  // Remove scroll event listener on scroll parents
1290  state.scrollParents.forEach(function (target) {
1291    target.removeEventListener('scroll', state.updateBound);
1292  });
1293
1294  // Reset state
1295  state.updateBound = null;
1296  state.scrollParents = [];
1297  state.scrollElement = null;
1298  state.eventsEnabled = false;
1299  return state;
1300}
1301
1302/**
1303 * It will remove resize/scroll events and won't recalculate popper position
1304 * when they are triggered. It also won't trigger `onUpdate` callback anymore,
1305 * unless you call `update` method manually.
1306 * @method
1307 * @memberof Popper
1308 */
1309function disableEventListeners() {
1310  if (this.state.eventsEnabled) {
1311    cancelAnimationFrame(this.scheduleUpdate);
1312    this.state = removeEventListeners(this.reference, this.state);
1313  }
1314}
1315
1316/**
1317 * Tells if a given input is a number
1318 * @method
1319 * @memberof Popper.Utils
1320 * @param {*} input to check
1321 * @return {Boolean}
1322 */
1323function isNumeric(n) {
1324  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
1325}
1326
1327/**
1328 * Set the style to the given popper
1329 * @method
1330 * @memberof Popper.Utils
1331 * @argument {Element} element - Element to apply the style to
1332 * @argument {Object} styles
1333 * Object with a list of properties and values which will be applied to the element
1334 */
1335function setStyles(element, styles) {
1336  Object.keys(styles).forEach(function (prop) {
1337    var unit = '';
1338    // add unit if the value is numeric and is one of the following
1339    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
1340      unit = 'px';
1341    }
1342    element.style[prop] = styles[prop] + unit;
1343  });
1344}
1345
1346/**
1347 * Set the attributes to the given popper
1348 * @method
1349 * @memberof Popper.Utils
1350 * @argument {Element} element - Element to apply the attributes to
1351 * @argument {Object} styles
1352 * Object with a list of properties and values which will be applied to the element
1353 */
1354function setAttributes(element, attributes) {
1355  Object.keys(attributes).forEach(function (prop) {
1356    var value = attributes[prop];
1357    if (value !== false) {
1358      element.setAttribute(prop, attributes[prop]);
1359    } else {
1360      element.removeAttribute(prop);
1361    }
1362  });
1363}
1364
1365/**
1366 * @function
1367 * @memberof Modifiers
1368 * @argument {Object} data - The data object generated by `update` method
1369 * @argument {Object} data.styles - List of style properties - values to apply to popper element
1370 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
1371 * @argument {Object} options - Modifiers configuration and options
1372 * @returns {Object} The same data object
1373 */
1374function applyStyle(data) {
1375  // any property present in `data.styles` will be applied to the popper,
1376  // in this way we can make the 3rd party modifiers add custom styles to it
1377  // Be aware, modifiers could override the properties defined in the previous
1378  // lines of this modifier!
1379  setStyles(data.instance.popper, data.styles);
1380
1381  // any property present in `data.attributes` will be applied to the popper,
1382  // they will be set as HTML attributes of the element
1383  setAttributes(data.instance.popper, data.attributes);
1384
1385  // if arrowElement is defined and arrowStyles has some properties
1386  if (data.arrowElement && Object.keys(data.arrowStyles).length) {
1387    setStyles(data.arrowElement, data.arrowStyles);
1388  }
1389
1390  return data;
1391}
1392
1393/**
1394 * Set the x-placement attribute before everything else because it could be used
1395 * to add margins to the popper margins needs to be calculated to get the
1396 * correct popper offsets.
1397 * @method
1398 * @memberof Popper.modifiers
1399 * @param {HTMLElement} reference - The reference element used to position the popper
1400 * @param {HTMLElement} popper - The HTML element used as popper
1401 * @param {Object} options - Popper.js options
1402 */
1403function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
1404  // compute reference element offsets
1405  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
1406
1407  // compute auto placement, store placement inside the data object,
1408  // modifiers will be able to edit `placement` if needed
1409  // and refer to originalPlacement to know the original value
1410  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
1411
1412  popper.setAttribute('x-placement', placement);
1413
1414  // Apply `position` to popper before anything else because
1415  // without the position applied we can't guarantee correct computations
1416  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
1417
1418  return options;
1419}
1420
1421/**
1422 * @function
1423 * @memberof Popper.Utils
1424 * @argument {Object} data - The data object generated by `update` method
1425 * @argument {Boolean} shouldRound - If the offsets should be rounded at all
1426 * @returns {Object} The popper's position offsets rounded
1427 *
1428 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
1429 * good as it can be within reason.
1430 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
1431 *
1432 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
1433 * as well on High DPI screens).
1434 *
1435 * Firefox prefers no rounding for positioning and does not have blurriness on
1436 * high DPI screens.
1437 *
1438 * Only horizontal placement and left/right values need to be considered.
1439 */
1440function getRoundedOffsets(data, shouldRound) {
1441  var _data$offsets = data.offsets,
1442      popper = _data$offsets.popper,
1443      reference = _data$offsets.reference;
1444  var round = Math.round,
1445      floor = Math.floor;
1446
1447  var noRound = function noRound(v) {
1448    return v;
1449  };
1450
1451  var referenceWidth = round(reference.width);
1452  var popperWidth = round(popper.width);
1453
1454  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
1455  var isVariation = data.placement.indexOf('-') !== -1;
1456  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
1457  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
1458
1459  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
1460  var verticalToInteger = !shouldRound ? noRound : round;
1461
1462  return {
1463    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
1464    top: verticalToInteger(popper.top),
1465    bottom: verticalToInteger(popper.bottom),
1466    right: horizontalToInteger(popper.right)
1467  };
1468}
1469
1470var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
1471
1472/**
1473 * @function
1474 * @memberof Modifiers
1475 * @argument {Object} data - The data object generated by `update` method
1476 * @argument {Object} options - Modifiers configuration and options
1477 * @returns {Object} The data object, properly modified
1478 */
1479function computeStyle(data, options) {
1480  var x = options.x,
1481      y = options.y;
1482  var popper = data.offsets.popper;
1483
1484  // Remove this legacy support in Popper.js v2
1485
1486  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
1487    return modifier.name === 'applyStyle';
1488  }).gpuAcceleration;
1489  if (legacyGpuAccelerationOption !== undefined) {
1490    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
1491  }
1492  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
1493
1494  var offsetParent = getOffsetParent(data.instance.popper);
1495  var offsetParentRect = getBoundingClientRect(offsetParent);
1496
1497  // Styles
1498  var styles = {
1499    position: popper.position
1500  };
1501
1502  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
1503
1504  var sideA = x === 'bottom' ? 'top' : 'bottom';
1505  var sideB = y === 'right' ? 'left' : 'right';
1506
1507  // if gpuAcceleration is set to `true` and transform is supported,
1508  //  we use `translate3d` to apply the position to the popper we
1509  // automatically use the supported prefixed version if needed
1510  var prefixedProperty = getSupportedPropertyName('transform');
1511
1512  // now, let's make a step back and look at this code closely (wtf?)
1513  // If the content of the popper grows once it's been positioned, it
1514  // may happen that the popper gets misplaced because of the new content
1515  // overflowing its reference element
1516  // To avoid this problem, we provide two options (x and y), which allow
1517  // the consumer to define the offset origin.
1518  // If we position a popper on top of a reference element, we can set
1519  // `x` to `top` to make the popper grow towards its top instead of
1520  // its bottom.
1521  var left = void 0,
1522      top = void 0;
1523  if (sideA === 'bottom') {
1524    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
1525    // and not the bottom of the html element
1526    if (offsetParent.nodeName === 'HTML') {
1527      top = -offsetParent.clientHeight + offsets.bottom;
1528    } else {
1529      top = -offsetParentRect.height + offsets.bottom;
1530    }
1531  } else {
1532    top = offsets.top;
1533  }
1534  if (sideB === 'right') {
1535    if (offsetParent.nodeName === 'HTML') {
1536      left = -offsetParent.clientWidth + offsets.right;
1537    } else {
1538      left = -offsetParentRect.width + offsets.right;
1539    }
1540  } else {
1541    left = offsets.left;
1542  }
1543  if (gpuAcceleration && prefixedProperty) {
1544    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
1545    styles[sideA] = 0;
1546    styles[sideB] = 0;
1547    styles.willChange = 'transform';
1548  } else {
1549    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
1550    var invertTop = sideA === 'bottom' ? -1 : 1;
1551    var invertLeft = sideB === 'right' ? -1 : 1;
1552    styles[sideA] = top * invertTop;
1553    styles[sideB] = left * invertLeft;
1554    styles.willChange = sideA + ', ' + sideB;
1555  }
1556
1557  // Attributes
1558  var attributes = {
1559    'x-placement': data.placement
1560  };
1561
1562  // Update `data` attributes, styles and arrowStyles
1563  data.attributes = _extends({}, attributes, data.attributes);
1564  data.styles = _extends({}, styles, data.styles);
1565  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
1566
1567  return data;
1568}
1569
1570/**
1571 * Helper used to know if the given modifier depends from another one.<br />
1572 * It checks if the needed modifier is listed and enabled.
1573 * @method
1574 * @memberof Popper.Utils
1575 * @param {Array} modifiers - list of modifiers
1576 * @param {String} requestingName - name of requesting modifier
1577 * @param {String} requestedName - name of requested modifier
1578 * @returns {Boolean}
1579 */
1580function isModifierRequired(modifiers, requestingName, requestedName) {
1581  var requesting = find(modifiers, function (_ref) {
1582    var name = _ref.name;
1583    return name === requestingName;
1584  });
1585
1586  var isRequired = !!requesting && modifiers.some(function (modifier) {
1587    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
1588  });
1589
1590  if (!isRequired) {
1591    var _requesting = '`' + requestingName + '`';
1592    var requested = '`' + requestedName + '`';
1593    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
1594  }
1595  return isRequired;
1596}
1597
1598/**
1599 * @function
1600 * @memberof Modifiers
1601 * @argument {Object} data - The data object generated by update method
1602 * @argument {Object} options - Modifiers configuration and options
1603 * @returns {Object} The data object, properly modified
1604 */
1605function arrow(data, options) {
1606  var _data$offsets$arrow;
1607
1608  // arrow depends on keepTogether in order to work
1609  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
1610    return data;
1611  }
1612
1613  var arrowElement = options.element;
1614
1615  // if arrowElement is a string, suppose it's a CSS selector
1616  if (typeof arrowElement === 'string') {
1617    arrowElement = data.instance.popper.querySelector(arrowElement);
1618
1619    // if arrowElement is not found, don't run the modifier
1620    if (!arrowElement) {
1621      return data;
1622    }
1623  } else {
1624    // if the arrowElement isn't a query selector we must check that the
1625    // provided DOM node is child of its popper node
1626    if (!data.instance.popper.contains(arrowElement)) {
1627      console.warn('WARNING: `arrow.element` must be child of its popper element!');
1628      return data;
1629    }
1630  }
1631
1632  var placement = data.placement.split('-')[0];
1633  var _data$offsets = data.offsets,
1634      popper = _data$offsets.popper,
1635      reference = _data$offsets.reference;
1636
1637  var isVertical = ['left', 'right'].indexOf(placement) !== -1;
1638
1639  var len = isVertical ? 'height' : 'width';
1640  var sideCapitalized = isVertical ? 'Top' : 'Left';
1641  var side = sideCapitalized.toLowerCase();
1642  var altSide = isVertical ? 'left' : 'top';
1643  var opSide = isVertical ? 'bottom' : 'right';
1644  var arrowElementSize = getOuterSizes(arrowElement)[len];
1645
1646  //
1647  // extends keepTogether behavior making sure the popper and its
1648  // reference have enough pixels in conjunction
1649  //
1650
1651  // top/left side
1652  if (reference[opSide] - arrowElementSize < popper[side]) {
1653    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
1654  }
1655  // bottom/right side
1656  if (reference[side] + arrowElementSize > popper[opSide]) {
1657    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
1658  }
1659  data.offsets.popper = getClientRect(data.offsets.popper);
1660
1661  // compute center of the popper
1662  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
1663
1664  // Compute the sideValue using the updated popper offsets
1665  // take popper margin in account because we don't have this info available
1666  var css = getStyleComputedProperty(data.instance.popper);
1667  var popperMarginSide = parseFloat(css['margin' + sideCapitalized]

1668);
1669  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
1670
1671  // prevent arrowElement from being placed not contiguously to its popper
1672  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
1673
1674  data.arrowElement = arrowElement;
1675  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
1676
1677  return data;
1678}
1679
1680/**
1681 * Get the opposite placement variation of the given one
1682 * @method
1683 * @memberof Popper.Utils
1684 * @argument {String} placement variation
1685 * @returns {String} flipped placement variation
1686 */
1687function getOppositeVariation(variation) {
1688  if (variation === 'end') {
1689    return 'start';
1690  } else if (variation === 'start') {
1691    return 'end';
1692  }
1693  return variation;
1694}
1695
1696/**
1697 * List of accepted placements to use as values of the `placement` option.<br />
1698 * Valid placements are:
1699 * - `auto`
1700 * - `top`
1701 * - `right`
1702 * - `bottom`
1703 * - `left`
1704 *
1705 * Each placement can have a variation from this list:
1706 * - `-start`
1707 * - `-end`
1708 *
1709 * Variations are interpreted easily if you think of them as the left to right
1710 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
1711 * is right.<br />
1712 * Vertically (`left` and `right`), `start` is top and `end` is bottom.
1713 *
1714 * Some valid examples are:
1715 * - `top-end` (on top of reference, right aligned)
1716 * - `right-start` (on right of reference, top aligned)
1717 * - `bottom` (on bottom, centered)
1718 * - `auto-end` (on the side with more space available, alignment depends by placement)
1719 *
1720 * @static
1721 * @type {Array}
1722 * @enum {String}
1723 * @readonly
1724 * @method placements
1725 * @memberof Popper
1726 */
1727var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
1728
1729// Get rid of `auto` `auto-start` and `auto-end`
1730var validPlacements = placements.slice(3);
1731
1732/**
1733 * Given an initial placement, returns all the subsequent placements
1734 * clockwise (or counter-clockwise).
1735 *
1736 * @method
1737 * @memberof Popper.Utils
1738 * @argument {String} placement - A valid placement (it accepts variations)
1739 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
1740 * @returns {Array} placements including their variations
1741 */
1742function clockwise(placement) {
1743  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1744
1745  var index = validPlacements.indexOf(placement);
1746  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
1747  return counter ? arr.reverse() : arr;
1748}
1749
1750var BEHAVIORS = {
1751  FLIP: 'flip',
1752  CLOCKWISE: 'clockwise',
1753  COUNTERCLOCKWISE: 'counterclockwise'
1754};
1755
1756/**
1757 * @function
1758 * @memberof Modifiers
1759 * @argument {Object} data - The data object generated by update method
1760 * @argument {Object} options - Modifiers configuration and options
1761 * @returns {Object} The data object, properly modified
1762 */
1763function flip(data, options) {
1764  // if `inner` modifier is enabled, we can't use the `flip` modifier
1765  if (isModifierEnabled(data.instance.modifiers, 'inner')) {
1766    return data;
1767  }
1768
1769  if (data.flipped && data.placement === data.originalPlacement) {
1770    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
1771    return data;
1772  }
1773
1774  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
1775
1776  var placement = data.placement.split('-')[0];
1777  var placementOpposite = getOppositePlacement(placement);
1778  var variation = data.placement.split('-')[1] || '';
1779
1780  var flipOrder = [];
1781
1782  switch (options.behavior) {
1783    case BEHAVIORS.FLIP:
1784      flipOrder = [placement, placementOpposite];
1785      break;
1786    case BEHAVIORS.CLOCKWISE:
1787      flipOrder = clockwise(placement);
1788      break;
1789    case BEHAVIORS.COUNTERCLOCKWISE:
1790      flipOrder = clockwise(placement, true);
1791      break;
1792    default:
1793      flipOrder = options.behavior;
1794  }
1795
1796  flipOrder.forEach(function (step, index) {
1797    if (placement !== step || flipOrder.length === index + 1) {
1798      return data;
1799    }
1800
1801    placement = data.placement.split('-')[0];
1802    placementOpposite = getOppositePlacement(placement);
1803
1804    var popperOffsets = data.offsets.popper;
1805    var refOffsets = data.offsets.reference;
1806
1807    // using floor because the reference offsets may contain decimals we are not going to consider here
1808    var floor = Math.floor;
1809    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
1810
1811    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
1812    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
1813    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
1814    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
1815
1816    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
1817
1818    // flip the variation if required
1819    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1820
1821    // flips variation if reference element overflows boundaries
1822    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
1823
1824    // flips variation if popper content overflows boundaries
1825    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
1826
1827    var flippedVariation = flippedVariationByRef || flippedVariationByContent;
1828
1829    if (overlapsRef || overflowsBoundaries || flippedVariation) {
1830      // this boolean to detect any flip loop
1831      data.flipped = true;
1832
1833      if (overlapsRef || overflowsBoundaries) {
1834        placement = flipOrder[index + 1];
1835      }
1836
1837      if (flippedVariation) {
1838        variation = getOppositeVariation(variation);
1839      }
1840
1841      data.placement = placement + (variation ? '-' + variation : '');
1842
1843      // this object contains `position`, we want to preserve it along with
1844      // any additional property we may add in the future
1845      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
1846
1847      data = runModifiers(data.instance.modifiers, data, 'flip');
1848    }
1849  });
1850  return data;
1851}
1852
1853/**
1854 * @function
1855 * @memberof Modifiers
1856 * @argument {Object} data - The data object generated by update method
1857 * @argument {Object} options - Modifiers configuration and options
1858 * @returns {Object} The data object, properly modified
1859 */
1860function keepTogether(data) {
1861  var _data$offsets = data.offsets,
1862      popper = _data$offsets.popper,
1863      reference = _data$offsets.reference;
1864
1865  var placement = data.placement.split('-')[0];
1866  var floor = Math.floor;
1867  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1868  var side = isVertical ? 'right' : 'bottom';
1869  var opSide = isVertical ? 'left' : 'top';
1870  var measurement = isVertical ? 'width' : 'height';
1871
1872  if (popper[side] < floor(reference[opSide])) {
1873    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
1874  }
1875  if (popper[opSide] > floor(reference[side])) {
1876    data.offsets.popper[opSide] = floor(reference[side]);
1877  }
1878
1879  return data;
1880}
1881
1882/**
1883 * Converts a string containing value + unit into a px value number
1884 * @function
1885 * @memberof {modifiers~offset}
1886 * @private
1887 * @argument {String} str - Value + unit string
1888 * @argument {String} measurement - `height` or `width`
1889 * @argument {Object} popperOffsets
1890 * @argument {Object} referenceOffsets
1891 * @returns {Number|String}
1892 * Value in pixels, or original string if no values were extracted
1893 */
1894function toValue(str, measurement, popperOffsets, referenceOffsets) {
1895  // separate value from unit
1896  var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
1897  var value = +split[1];
1898  var unit = split[2];
1899
1900  // If it's not a number it's an operator, I guess
1901  if (!value) {
1902    return str;
1903  }
1904
1905  if (unit.indexOf('%') === 0) {
1906    var element = void 0;
1907    switch (unit) {
1908      case '%p':
1909        element = popperOffsets;
1910        break;
1911      case '%':
1912      case '%r':
1913      default:
1914        element = referenceOffsets;
1915    }
1916
1917    var rect = getClientRect(element);
1918    return rect[measurement] / 100 * value;
1919  } else if (unit === 'vh' || unit === 'vw') {
1920    // if is a vh or vw, we calculate the size based on the viewport
1921    var size = void 0;
1922    if (unit === 'vh') {
1923      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
1924    } else {
1925      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
1926    }
1927    return size / 100 * value;
1928  } else {
1929    // if is an explicit pixel unit, we get rid of the unit and keep the value
1930    // if is an implicit unit, it's px, and we return just the value
1931    return value;
1932  }
1933}
1934
1935/**
1936 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
1937 * @function
1938 * @memberof {modifiers~offset}
1939 * @private
1940 * @argument {String} offset
1941 * @argument {Object} popperOffsets
1942 * @argument {Object} referenceOffsets
1943 * @argument {String} basePlacement
1944 * @returns {Array} a two cells array with x and y offsets in numbers
1945 */
1946function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
1947  var offsets = [0, 0];
1948
1949  // Use height if placement is left or right and index is 0 otherwise use width
1950  // in this way the first offset will use an axis and the second one
1951  // will use the other one
1952  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
1953
1954  // Split the offset string to obtain a list of values and operands
1955  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
1956  var fragments = offset.split(/(\+|\-)/).map(function (frag) {
1957    return frag.trim();
1958  });
1959
1960  // Detect if the offset string contains a pair of values or a single one
1961  // they could be separated by comma or space
1962  var divider = fragments.indexOf(find(fragments, function (frag) {
1963    return frag.search(/,|\s/) !== -1;
1964  }));
1965
1966  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
1967    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
1968  }
1969
1970  // If divider is found, we divide the list of values and operands to divide
1971  // them by ofset X and Y.
1972  var splitRegex = /\s*,\s*|\s+/;
1973  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
1974
1975  // Convert the values with units to absolute pixels to allow our computations
1976  ops = ops.map(function (op, index) {
1977    // Most of the units rely on the orientation of the popper
1978    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
1979    var mergeWithPrevious = false;
1980    return op
1981    // This aggregates any `+` or `-` sign that aren't considered operators
1982    // e.g.: 10 + +5 => [10, +, +5]
1983    .reduce(function (a, b) {
1984      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
1985        a[a.length - 1] = b;
1986        mergeWithPrevious = true;
1987        return a;
1988      } else if (mergeWithPrevious) {
1989        a[a.length - 1] += b;
1990        mergeWithPrevious = false;
1991        return a;
1992      } else {
1993        return a.concat(b);
1994      }
1995    }, [])
1996    // Here we convert the string values into number values (in px)
1997    .map(function (str) {
1998      return toValue(str, measurement, popperOffsets, referenceOffsets);
1999    });
2000  });
2001
2002  // Loop trough the offsets arrays and execute the operations
2003  ops.forEach(function (op, index) {
2004    op.forEach(function (frag, index2) {
2005      if (isNumeric(frag)) {
2006        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
2007      }
2008    });
2009  });
2010  return offsets;
2011}
2012
2013/**
2014 * @function
2015 * @memberof Modifiers
2016 * @argument {Object} data - The data object generated by update method
2017 * @argument {Object} options - Modifiers configuration and options
2018 * @argument {Number|String} options.offset=0
2019 * The offset value as described in the modifier description
2020 * @returns {Object} The data object, properly modified
2021 */
2022function offset(data, _ref) {
2023  var offset = _ref.offset;
2024  var placement = data.placement,
2025      _data$offsets = data.offsets,
2026      popper = _data$offsets.popper,
2027      reference = _data$offsets.reference;
2028
2029  var basePlacement = placement.split('-')[0];
2030
2031  var offsets = void 0;
2032  if (isNumeric(+offset)) {
2033    offsets = [+offset, 0];
2034  } else {
2035    offsets = parseOffset(offset, popper, reference, basePlacement);
2036  }
2037
2038  if (basePlacement === 'left') {
2039    popper.top += offsets[0];
2040    popper.left -= offsets[1];
2041  } else if (basePlacement === 'right') {
2042    popper.top += offsets[0];
2043    popper.left += offsets[1];
2044  } else if (basePlacement === 'top') {
2045    popper.left += offsets[0];
2046    popper.top -= offsets[1];
2047  } else if (basePlacement === 'bottom') {
2048    popper.left += offsets[0];
2049    popper.top += offsets[1];
2050  }
2051
2052  data.popper = popper;
2053  return data;
2054}
2055
2056/**
2057 * @function
2058 * @memberof Modifiers
2059 * @argument {Object} data - The data object generated by `update` method
2060 * @argument {Object} options - Modifiers configuration and options
2061 * @returns {Object} The data object, properly modified
2062 */
2063function preventOverflow(data, options) {
2064  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
2065
2066  // If offsetParent is the reference element, we really want to
2067  // go one step up and use the next offsetParent as reference to
2068  // avoid to make this modifier completely useless and look like broken
2069  if (data.instance.reference === boundariesElement) {
2070    boundariesElement = getOffsetParent(boundariesElement);
2071  }
2072
2073  // NOTE: DOM access here
2074  // resets the popper's position so that the document size can be calculated excluding
2075  // the size of the popper element itself
2076  var transformProp = getSupportedPropertyName('transform');
2077  var popperStyles = data.instance.popper.style; // assignment to help minification
2078  var top = popperStyles.top,
2079      left = popperStyles.left,
2080      transform = popperStyles[transformProp];
2081
2082  popperStyles.top = '';
2083  popperStyles.left = '';
2084  popperStyles[transformProp] = '';
2085
2086  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
2087
2088  // NOTE: DOM access here
2089  // restores the original style properties after the offsets have been computed
2090  popperStyles.top = top;
2091  popperStyles.left = left;
2092  popperStyles[transformProp] = transform;
2093
2094  options.boundaries = boundaries;
2095
2096  var order = options.priority;
2097  var popper = data.offsets.popper;
2098
2099  var check = {
2100    primary: function primary(placement) {
2101      var value = popper[placement];
2102      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
2103        value = Math.max(popper[placement], boundaries[placement]);
2104      }
2105      return defineProperty({}, placement, value);
2106    },
2107    secondary: function secondary(placement) {
2108      var mainSide = placement === 'right' ? 'left' : 'top';
2109      var value = popper[mainSide];
2110      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
2111        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
2112      }
2113      return defineProperty({}, mainSide, value);
2114    }
2115  };
2116
2117  order.forEach(function (placement) {
2118    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
2119    popper = _extends({}, popper, check[side](placement));
2120  });
2121
2122  data.offsets.popper = popper;
2123
2124  return data;
2125}
2126
2127/**
2128 * @function
2129 * @memberof Modifiers
2130 * @argument {Object} data - The data object generated by `update` method
2131 * @argument {Object} options - Modifiers configuration and options
2132 * @returns {Object} The data object, properly modified
2133 */
2134function shift(data) {
2135  var placement = data.placement;
2136  var basePlacement = placement.split('-')[0];
2137  var shiftvariation = placement.split('-')[1];
2138
2139  // if shift shiftvariation is specified, run the modifier
2140  if (shiftvariation) {
2141    var _data$offsets = data.offsets,
2142        reference = _data$offsets.reference,
2143        popper = _data$offsets.popper;
2144
2145    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
2146    var side = isVertical ? 'left' : 'top';
2147    var measurement = isVertical ? 'width' : 'height';
2148
2149    var shiftOffsets = {
2150      start: defineProperty({}, side, reference[side]),
2151      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
2152    };
2153
2154    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
2155  }
2156
2157  return data;
2158}
2159
2160/**
2161 * @function
2162 * @memberof Modifiers
2163 * @argument {Object} data - The data object generated by update method
2164 * @argument {Object} options - Modifiers configuration and options
2165 * @returns {Object} The data object, properly modified
2166 */
2167function hide(data) {
2168  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
2169    return data;
2170  }
2171
2172  var refRect = data.offsets.reference;
2173  var bound = find(data.instance.modifiers, function (modifier) {
2174    return modifier.name === 'preventOverflow';
2175  }).boundaries;
2176
2177  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
2178    // Avoid unnecessary DOM access if visibility hasn't changed
2179    if (data.hide === true) {
2180      return data;
2181    }
2182
2183    data.hide = true;
2184    data.attributes['x-out-of-boundaries'] = '';
2185  } else {
2186    // Avoid unnecessary DOM access if visibility hasn't changed
2187    if (data.hide === false) {
2188      return data;
2189    }
2190
2191    data.hide = false;
2192    data.attributes['x-out-of-boundaries'] = false;
2193  }
2194
2195  return data;
2196}
2197
2198/**
2199 * @function
2200 * @memberof Modifiers
2201 * @argument {Object} data - The data object generated by `update` method
2202 * @argument {Object} options - Modifiers configuration and options
2203 * @returns {Object} The data object, properly modified
2204 */
2205function inner(data) {
2206  var placement = data.placement;
2207  var basePlacement = placement.split('-')[0];
2208  var _data$offsets = data.offsets,
2209      popper = _data$offsets.popper,
2210      reference = _data$offsets.reference;
2211
2212  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
2213
2214  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
2215
2216  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
2217
2218  data.placement = getOppositePlacement(placement);
2219  data.offsets.popper = getClientRect(popper);
2220
2221  return data;
2222}
2223
2224/**
2225 * Modifier function, each modifier can have a function of this type assigned
2226 * to its `fn` property.<br />
2227 * These functions will be called on each update, this means that you must
2228 * make sure they are performant enough to avoid performance bottlenecks.
2229 *
2230 * @function ModifierFn
2231 * @argument {dataObject} data - The data object generated by `update` method
2232 * @argument {Object} options - Modifiers configuration and options
2233 * @returns {dataObject} The data object, properly modified
2234 */
2235
2236/**
2237 * Modifiers are plugins used to alter the behavior of your poppers.<br />
2238 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
2239 * needed by the library.
2240 *
2241 * Usually you don't want to override the `order`, `fn` and `onLoad` props.
2242 * All the other properties are configurations that could be tweaked.
2243 * @namespace modifiers
2244 */
2245var modifiers = {
2246  /**
2247   * Modifier used to shift the popper on the start or end of its reference
2248   * element.<br />
2249   * It will read the variation of the `placement` property.<br />
2250   * It can be one either `-end` or `-start`.
2251   * @memberof modifiers
2252   * @inner
2253   */
2254  shift: {
2255    /** @prop {number} order=100 - Index used to define the order of execution */
2256    order: 100,
2257    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2258    enabled: true,
2259    /** @prop {ModifierFn} */
2260    fn: shift
2261  },
2262
2263  /**
2264   * The `offset` modifier can shift your popper on both its axis.
2265   *
2266   * It accepts the following units:
2267   * - `px` or unit-less, interpreted as pixels
2268   * - `%` or `%r`, percentage relative to the length of the reference element
2269   * - `%p`, percentage relative to the length of the popper element
2270   * - `vw`, CSS viewport width unit
2271   * - `vh`, CSS viewport height unit
2272   *
2273   * For length is intended the main axis relative to the placement of the popper.<br />
2274   * This means that if the placement is `top` or `bottom`, the length will be the
2275   * `width`. In case of `left` or `right`, it will be the `height`.
2276   *
2277   * You can provide a single value (as `Number` or `String`), or a pair of values
2278   * as `String` divided by a comma or one (or more) white space

2278s.<br />
2279   * The latter is a deprecated method because it leads to confusion and will be
2280   * removed in v2.<br />
2281   * Additionally, it accepts additions and subtractions between different units.
2282   * Note that multiplications and divisions aren't supported.
2283   *
2284   * Valid examples are:
2285   * ```
2286   * 10
2287   * '10%'
2288   * '10, 10'
2289   * '10%, 10'
2290   * '10 + 10%'
2291   * '10 - 5vh + 3%'
2292   * '-10px + 5vh, 5px - 6%'
2293   * ```
2294   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
2295   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
2296   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
2297   *
2298   * @memberof modifiers
2299   * @inner
2300   */
2301  offset: {
2302    /** @prop {number} order=200 - Index used to define the order of execution */
2303    order: 200,
2304    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2305    enabled: true,
2306    /** @prop {ModifierFn} */
2307    fn: offset,
2308    /** @prop {Number|String} offset=0
2309     * The offset value as described in the modifier description
2310     */
2311    offset: 0
2312  },
2313
2314  /**
2315   * Modifier used to prevent the popper from being positioned outside the boundary.
2316   *
2317   * A scenario exists where the reference itself is not within the boundaries.<br />
2318   * We can say it has "escaped the boundaries" — or just "escaped".<br />
2319   * In this case we need to decide whether the popper should either:
2320   *
2321   * - detach from the reference and remain "trapped" in the boundaries, or
2322   * - if it should ignore the boundary and "escape with its reference"
2323   *
2324   * When `escapeWithReference` is set to`true` and reference is completely
2325   * outside its boundaries, the popper will overflow (or completely leave)
2326   * the boundaries in order to remain attached to the edge of the reference.
2327   *
2328   * @memberof modifiers
2329   * @inner
2330   */
2331  preventOverflow: {
2332    /** @prop {number} order=300 - Index used to define the order of execution */
2333    order: 300,
2334    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2335    enabled: true,
2336    /** @prop {ModifierFn} */
2337    fn: preventOverflow,
2338    /**
2339     * @prop {Array} [priority=['left','right','top','bottom']]
2340     * Popper will try to prevent overflow following these priorities by default,
2341     * then, it could overflow on the left and on top of the `boundariesElement`
2342     */
2343    priority: ['left', 'right', 'top', 'bottom'],
2344    /**
2345     * @prop {number} padding=5
2346     * Amount of pixel used to define a minimum distance between the boundaries
2347     * and the popper. This makes sure the popper always has a little padding
2348     * between the edges of its container
2349     */
2350    padding: 5,
2351    /**
2352     * @prop {String|HTMLElement} boundariesElement='scrollParent'
2353     * Boundaries used by the modifier. Can be `scrollParent`, `window`,
2354     * `viewport` or any DOM element.
2355     */
2356    boundariesElement: 'scrollParent'
2357  },
2358
2359  /**
2360   * Modifier used to make sure the reference and its popper stay near each other
2361   * without leaving any gap between the two. Especially useful when the arrow is
2362   * enabled and you want to ensure that it points to its reference element.
2363   * It cares only about the first axis. You can still have poppers with margin
2364   * between the popper and its reference element.
2365   * @memberof modifiers
2366   * @inner
2367   */
2368  keepTogether: {
2369    /** @prop {number} order=400 - Index used to define the order of execution */
2370    order: 400,
2371    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2372    enabled: true,
2373    /** @prop {ModifierFn} */
2374    fn: keepTogether
2375  },
2376
2377  /**
2378   * This modifier is used to move the `arrowElement` of the popper to make
2379   * sure it is positioned between the reference element and its popper element.
2380   * It will read the outer size of the `arrowElement` node to detect how many
2381   * pixels of conjunction are needed.
2382   *
2383   * It has no effect if no `arrowElement` is provided.
2384   * @memberof modifiers
2385   * @inner
2386   */
2387  arrow: {
2388    /** @prop {number} order=500 - Index used to define the order of execution */
2389    order: 500,
2390    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2391    enabled: true,
2392    /** @prop {ModifierFn} */
2393    fn: arrow,
2394    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
2395    element: '[x-arrow]'
2396  },
2397
2398  /**
2399   * Modifier used to flip the popper's placement when it starts to overlap its
2400   * reference element.
2401   *
2402   * Requires the `preventOverflow` modifier before it in order to work.
2403   *
2404   * **NOTE:** this modifier will interrupt the current update cycle and will
2405   * restart it if it detects the need to flip the placement.
2406   * @memberof modifiers
2407   * @inner
2408   */
2409  flip: {
2410    /** @prop {number} order=600 - Index used to define the order of execution */
2411    order: 600,
2412    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2413    enabled: true,
2414    /** @prop {ModifierFn} */
2415    fn: flip,
2416    /**
2417     * @prop {String|Array} behavior='flip'
2418     * The behavior used to change the popper's placement. It can be one of
2419     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
2420     * placements (with optional variations)
2421     */
2422    behavior: 'flip',
2423    /**
2424     * @prop {number} padding=5
2425     * The popper will flip if it hits the edges of the `boundariesElement`
2426     */
2427    padding: 5,
2428    /**
2429     * @prop {String|HTMLElement} boundariesElement='viewport'
2430     * The element which will define the boundaries of the popper position.
2431     * The popper will never be placed outside of the defined boundaries
2432     * (except if `keepTogether` is enabled)
2433     */
2434    boundariesElement: 'viewport',
2435    /**
2436     * @prop {Boolean} flipVariations=false
2437     * The popper will switch placement variation between `-start` and `-end` when
2438     * the reference element overlaps its boundaries.
2439     *
2440     * The original placement should have a set variation.
2441     */
2442    flipVariations: false,
2443    /**
2444     * @prop {Boolean} flipVariationsByContent=false
2445     * The popper will switch placement variation between `-start` and `-end` when
2446     * the popper element overlaps its reference boundaries.
2447     *
2448     * The original placement should have a set variation.
2449     */
2450    flipVariationsByContent: false
2451  },
2452
2453  /**
2454   * Modifier used to make the popper flow toward the inner of the reference element.
2455   * By default, when this modifier is disabled, the popper will be placed outside
2456   * the reference element.
2457   * @memberof modifiers
2458   * @inner
2459   */
2460  inner: {
2461    /** @prop {number} order=700 - Index used to define the order of execution */
2462    order: 700,
2463    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
2464    enabled: false,
2465    /** @prop {ModifierFn} */
2466    fn: inner
2467  },
2468
2469  /**
2470   * Modifier used to hide the popper when its reference element is outside of the
2471   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
2472   * be used to hide with a CSS selector the popper when its reference is
2473   * out of boundaries.
2474   *
2475   * Requires the `preventOverflow` modifier before it in order to work.
2476   * @memberof modifiers
2477   * @inner
2478   */
2479  hide: {
2480    /** @prop {number} order=800 - Index used to define the order of execution */
2481    order: 800,
2482    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2483    enabled: true,
2484    /** @prop {ModifierFn} */
2485    fn: hide
2486  },
2487
2488  /**
2489   * Computes the style that will be applied to the popper element to gets
2490   * properly positioned.
2491   *
2492   * Note that this modifier will not touch the DOM, it just prepares the styles
2493   * so that `applyStyle` modifier can apply it. This separation is useful
2494   * in case you need to replace `applyStyle` with a custom implementation.
2495   *
2496   * This modifier has `850` as `order` value to maintain backward compatibility
2497   * with previous versions of Popper.js. Expect the modifiers ordering method
2498   * to change in future major versions of the library.
2499   *
2500   * @memberof modifiers
2501   * @inner
2502   */
2503  computeStyle: {
2504    /** @prop {number} order=850 - Index used to define the order of execution */
2505    order: 850,
2506    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2507    enabled: true,
2508    /** @prop {ModifierFn} */
2509    fn: computeStyle,
2510    /**
2511     * @prop {Boolean} gpuAcceleration=true
2512     * If true, it uses the CSS 3D transformation to position the popper.
2513     * Otherwise, it will use the `top` and `left` properties
2514     */
2515    gpuAcceleration: true,
2516    /**
2517     * @prop {string} [x='bottom']
2518     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
2519     * Change this if your popper should grow in a direction different from `bottom`
2520     */
2521    x: 'bottom',
2522    /**
2523     * @prop {string} [x='left']
2524     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
2525     * Change this if your popper should grow in a direction different from `right`
2526     */
2527    y: 'right'
2528  },
2529
2530  /**
2531   * Applies the computed styles to the popper element.
2532   *
2533   * All the DOM manipulations are limited to this modifier. This is useful in case
2534   * you want to integrate Popper.js inside a framework or view library and you
2535   * want to delegate all the DOM manipulations to it.
2536   *
2537   * Note that if you disable this modifier, you must make sure the popper element
2538   * has its position set to `absolute` before Popper.js can do its work!
2539   *
2540   * Just disable this modifier and define your own to achieve the desired effect.
2541   *
2542   * @memberof modifiers
2543   * @inner
2544   */
2545  applyStyle: {
2546    /** @prop {number} order=900 - Index used to define the order of execution */
2547    order: 900,
2548    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2549    enabled: true,
2550    /** @prop {ModifierFn} */

2551    fn: applyStyle,
2552    /** @prop {Function} */
2553    onLoad: applyStyleOnLoad,
2554    /**
2555     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
2556     * @prop {Boolean} gpuAcceleration=true
2557     * If true, it uses the CSS 3D transformation to position the popper.
2558     * Otherwise, it will use the `top` and `left` properties
2559     */
2560    gpuAcceleration: undefined
2561  }
2562};
2563
2564/**
2565 * The `dataObject` is an object containing all the information used by Popper.js.
2566 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
2567 * @name dataObject
2568 * @property {Object} data.instance The Popper.js instance
2569 * @property {String} data.placement Placement applied to popper
2570 * @property {String} data.originalPlacement Placement originally defined on init
2571 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
2572 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
2573 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
2574 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
2575 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
2576 * @property {Object} data.boundaries Offsets of the popper boundaries
2577 * @property {Object} data.offsets The measurements of popper, reference and arrow elements
2578 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
2579 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
2580 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
2581 */
2582
2583/**
2584 * Default options provided to Popper.js constructor.<br />
2585 * These can be overridden using the `options` argument of Popper.js.<br />
2586 * To override an option, simply pass an object with the same
2587 * structure of the `options` object, as the 3rd argument. For example:
2588 * ```
2589 * new Popper(ref, pop, {
2590 *   modifiers: {
2591 *     preventOverflow: { enabled: false }
2592 *   }
2593 * })
2594 * ```
2595 * @type {Object}
2596 * @static
2597 * @memberof Popper
2598 */
2599var Defaults = {
2600  /**
2601   * Popper's placement.
2602   * @prop {Popper.placements} placement='bottom'
2603   */
2604  placement: 'bottom',
2605
2606  /**
2607   * Set this to true if you want popper to position it self in 'fixed' mode
2608   * @prop {Boolean} positionFixed=false
2609   */
2610  positionFixed: false,
2611
2612  /**
2613   * Whether events (resize, scroll) are initially enabled.
2614   * @prop {Boolean} eventsEnabled=true
2615   */
2616  eventsEnabled: true,
2617
2618  /**
2619   * Set to true if you want to automatically remove the popper when
2620   * you call the `destroy` method.
2621   * @prop {Boolean} removeOnDestroy=false
2622   */
2623  removeOnDestroy: false,
2624
2625  /**
2626   * Callback called when the popper is created.<br />
2627   * By default, it is set to no-op.<br />
2628   * Access Popper.js instance with `data.instance`.
2629   * @prop {onCreate}
2630   */
2631  onCreate: function onCreate() {},
2632
2633  /**
2634   * Callback called when the popper is updated. This callback is not called
2635   * on the initialization/creation of the popper, but only on subsequent
2636   * updates.<br />
2637   * By default, it is set to no-op.<br />
2638   * Access Popper.js instance with `data.instance`.
2639   * @prop {onUpdate}
2640   */
2641  onUpdate: function onUpdate() {},
2642
2643  /**
2644   * List of modifiers used to modify the offsets before they are applied to the popper.
2645   * They provide most of the functionalities of Popper.js.
2646   * @prop {modifiers}
2647   */
2648  modifiers: modifiers
2649};
2650
2651/**
2652 * @callback onCreate
2653 * @param {dataObject} data
2654 */
2655
2656/**
2657 * @callback onUpdate
2658 * @param {dataObject} data
2659 */
2660
2661// Utils
2662// Methods
2663var Popper = function () {
2664  /**
2665   * Creates a new Popper.js instance.
2666   * @class Popper
2667   * @param {Element|referenceObject} reference - The reference element used to position the popper
2668   * @param {Element} popper - The HTML / XML element used as the popper
2669   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
2670   * @return {Object} instance - The generated Popper.js instance
2671   */
2672  function Popper(reference, popper) {
2673    var _this = this;
2674
2675    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
2676    classCallCheck(this, Popper);
2677
2678    this.scheduleUpdate = function () {
2679      return requestAnimationFrame(_this.update);
2680    };
2681
2682    // make update() debounced, so that it only runs at most once-per-tick
2683    this.update = debounce(this.update.bind(this));
2684
2685    // with {} we create a new object with the options inside it
2686    this.options = _extends({}, Popper.Defaults, options);
2687
2688    // init state
2689    this.state = {
2690      isDestroyed: false,
2691      isCreated: false,
2692      scrollParents: []
2693    };
2694
2695    // get reference and popper elements (allow jQuery wrappers)
2696    this.reference = reference && reference.jquery ? reference[0] : reference;
2697    this.popper = popper && popper.jquery ? popper[0] : popper;
2698
2699    // Deep merge modifiers options
2700    this.options.modifiers = {};
2701    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
2702      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
2703    });
2704
2705    // Refactoring modifiers' list (Object => Array)
2706    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
2707      return _extends({
2708        name: name
2709      }, _this.options.modifiers[name]);
2710    })
2711    // sort the modifiers by order
2712    .sort(function (a, b) {
2713      return a.order - b.order;
2714    });
2715
2716    // modifiers have the ability to execute arbitrary code when Popper.js get inited
2717    // such code is executed in the same order of its modifier
2718    // they could add new properties to their options configuration
2719    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
2720    this.modifiers.forEach(function (modifierOptions) {
2721      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
2722        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
2723      }
2724    });
2725
2726    // fire the first update to position the popper in the right place
2727    this.update();
2728
2729    var eventsEnabled = this.options.eventsEnabled;
2730    if (eventsEnabled) {
2731      // setup event listeners, they will take care of update the position in specific situations
2732      this.enableEventListeners();
2733    }
2734
2735    this.state.eventsEnabled = eventsEnabled;
2736  }
2737
2738  // We can't use class properties because they don't get listed in the
2739  // class prototype and break stuff like Sinon stubs
2740
2741
2742  createClass(Popper, [{
2743    key: 'update',
2744    value: function update$$1() {
2745      return update.call(this);
2746    }
2747  }, {
2748    key: 'destroy',
2749    value: function destroy$$1() {
2750      return destroy.call(this);
2751    }
2752  }, {
2753    key: 'enableEventListeners',
2754    value: function enableEventListeners$$1() {
2755      return enableEventListeners.call(this);
2756    }
2757  }, {
2758    key: 'disableEventListeners',
2759    value: function disableEventListeners$$1() {
2760      return disableEventListeners.call(this);
2761    }
2762
2763    /**
2764     * Schedules an update. It will run on the next UI update available.
2765     * @method scheduleUpdate
2766     * @memberof Popper
2767     */
2768
2769
2770    /**
2771     * Collection of utilities useful when writing custom modifiers.
2772     * Starting from version 1.7, this method is available only if you
2773     * include `popper-utils.js` before `popper.js`.
2774     *
2775     * **DEPRECATION**: This way to access PopperUtils is deprecated
2776     * and will be removed in v2! Use the PopperUtils module directly instead.
2777     * Due to the high instability of the methods contained in Utils, we can't
2778     * guarantee them to follow semver. Use them at your own risk!
2779     * @static
2780     * @private
2781     * @type {Object}
2782     * @deprecated since version 1.8
2783     * @member Utils
2784     * @memberof Popper
2785     */
2786
2787  }]);
2788  return Popper;
2789}();
2790
2791/**
2792 * The `referenceObject` is an object that provides an interface compatible with Popper.js
2793 * and lets you use it as replacement of a real DOM node.<br />
2794 * You can use this method to position a popper relatively to a set of coordinates
2795 * in case you don't have a DOM node to use as reference.
2796 *
2797 * ```
2798 * new Popper(referenceObject, popperNode);
2799 * ```
2800 *
2801 * NB: This feature isn't supported in Internet Explorer 10.
2802 * @name referenceObject
2803 * @property {Function} data.getBoundingClientRect
2804 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
2805 * @property {number} data.clientWidth
2806 * An ES6 getter that will return the width of the virtual reference element.
2807 * @property {number} data.clientHeight
2808 * An ES6 getter that will return the height of the virtual reference element.
2809 */
2810
2811
2812Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
2813Popper.placements = placements;
2814Popper.Defaults = Defaults;
2815