https://www.smumn.edu/wp-content/themes/smumn-2022/build/js/vendor.min.js?ver=2.6.4

32
33var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
34
35var timeoutDuration = function () {
36  var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
37  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
38    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
39      return 1;
40    }
41  }
42  return 0;
43}();
44
45function microtaskDebounce(fn) {
46  var called = false;
47  return function () {
48    if (called) {
49      return;
50    }
51    called = true;
52    window.Promise.resolve().then(function () {
53      called = false;
54      fn();
55    });
56  };
57}
58
59function taskDebounce(fn) {
60  var scheduled = false;
61  return function () {
62    if (!scheduled) {
63      scheduled = true;
64      setTimeout(function () {
65        scheduled = false;
66        fn();
67      }, timeoutDuration);
68    }
69  };
70}
71
72var supportsMicroTasks = isBrowser && window.Promise;
73
74/**
75* Create a debounced version of a method, that's asynchronously deferred
76* but called in the minimum time possible.
77*
78* @method
79* @memberof Popper.Utils
80* @argument {Function} fn
81* @returns {Function}
82*/
83var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
84
85/**
86 * Check if the given variable is a function
87 * @method
88 * @memberof Popper.Utils
89 * @argument {Any} functionToCheck - variable to check
90 * @returns {Boolean} answer to: is a function?
91 */
92function isFunction(functionToCheck) {
93  var getType = {};
94  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
95}
96
97/**
98 * Get CSS computed property of the given element
99 * @method
100 * @memberof Popper.Utils
101 * @argument {Eement} element
102 * @argument {String} property
103 */
104function getStyleComputedProperty(element, property) {
105  if (element.nodeType !== 1) {
106    return [];
107  }
108  // NOTE: 1 DOM access here
109  var window = element.ownerDocument.defaultView;
110  var css = window.getComputedStyle(element, null);
111  return property ? css[property] : css;
112}
113
114/**
115 * Returns the parentNode or the host of the element
116 * @method
117 * @memberof Popper.Utils
118 * @argument {Element} element
119 * @returns {Element} parent
120 */
121function getParentNode(element) {
122  if (element.nodeName === 'HTML') {
123    return element;
124  }
125  return element.parentNode || element.host;
126}
127
128/**
129 * Returns the scrolling parent of the given element
130 * @method
131 * @memberof Popper.Utils
132 * @argument {Element} element
133 * @returns {Element} scroll parent
134 */
135function getScrollParent(element) {
136  // Return body, `getScroll` will take care to get the correct `scrollTop` from it
137  if (!element) {
138    return document.body;
139  }
140
141  switch (element.nodeName) {
142    case 'HTML':
143    case 'BODY':
144      return element.ownerDocument.body;
145    case '#document':
146      return element.body;
147  }
148
149  // Firefox want us to check `-x` and `-y` variations as well
150
151  var _getStyleComputedProp = getStyleComputedProperty(element),
152      overflow = _getStyleComputedProp.overflow,
153      overflowX = _getStyleComputedProp.overflowX,
154      overflowY = _getStyleComputedProp.overflowY;
155
156  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
157    return element;
158  }
159
160  return getScrollParent(getParentNode(element));
161}
162
163/**
164 * Returns the reference node of the reference object, or the reference object itself.
165 * @method
166 * @memberof Popper.Utils
167 * @param {Element|Object} reference - the reference element (the popper will be relative to this)
168 * @returns {Element} parent
169 */
170function getReferenceNode(reference) {
171  return reference && reference.referenceNode ? reference.referenceNode : reference;
172}
173
174var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
175var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
176
177/**
178 * Determines if the browser is Internet Explorer
179 * @method
180 * @memberof Popper.Utils
181 * @param {Number} version to check
182 * @returns {Boolean} isIE
183 */
184function isIE(version) {
185  if (version === 11) {
186    return isIE11;
187  }
188  if (version === 10) {
189    return isIE10;
190  }
191  return isIE11 || isIE10;
192}
193
194/**
195 * Returns the offset parent of the given element
196 * @method
197 * @memberof Popper.Utils
198 * @argument {Element} element
199 * @returns {Element} offset parent
200 */
201function getOffsetParent(element) {
202  if (!element) {
203    return document.documentElement;
204  }
205
206  var noOffsetParent = isIE(10) ? document.body : null;
207
208  // NOTE: 1 DOM access here
209  var offsetParent = element.offsetParent || null;
210  // Skip hidden elements which don't have an offsetParent
211  while (offsetParent === noOffsetParent && element.nextElementSibling) {
212    offsetParent = (element = element.nextElementSibling).offsetParent;
213  }
214
215  var nodeName = offsetParent && offsetParent.nodeName;
216
217  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
218    return element ? element.ownerDocument.documentElement : document.documentElement;
219  }
220
221  // .offsetParent will return the closest TH, TD or TABLE in case
222  // no offsetParent is present, I hate this job...
223  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
224    return getOffsetParent(offsetParent);
225  }
226
227  return offsetParent;
228}
229
230function isOffsetContainer(element) {
231  var nodeName = element.nodeName;
232
233  if (nodeName === 'BODY') {
234    return false;
235  }
236  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
237}
238
239/**
240 * Finds the root node (document, shadowDOM root) of the given element
241 * @method
242 * @memberof Popper.Utils
243 * @argument {Element} node
244 * @returns {Element} root node
245 */
246function getRoot(node) {
247  if (node.parentNode !== null) {
248    return getRoot(node.parentNode);
249  }
250
251  return node;
252}
253
254/**
255 * Finds the offset parent common to the two provided nodes
256 * @method
257 * @memberof Popper.Utils
258 * @argument {Element} element1
259 * @argument {Element} element2
260 * @returns {Element} common offset parent
261 */
262function findCommonOffsetParent(element1, element2) {
263  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
264  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
265    return document.documentElement;
266  }
267
268  // Here we make sure to give as "start" the element that comes first in the DOM
269  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
270  var start = order ? element1 : element2;
271  var end = order ? element2 : element1;
272
273  // Get common ancestor container
274  var range = document.createRange();
275  range.setStart(start, 0);
276  range.setEnd(end, 0);
277  var commonAncestorContainer = range.commonAncestorContainer;
278
279  // Both nodes are inside #document
280
281  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
282    if (isOffsetContainer(commonAncestorContainer)) {
283      return commonAncestorContainer;
284    }
285
286    return getOffsetParent(commonAncestorContainer);
287  }
288
289  // one of the nodes is inside shadowDOM, find which one
290  var element1root = getRoot(element1);
291  if (element1root.host) {
292    return findCommonOffsetParent(element1root.host, element2);
293  } else {
294    return findCommonOffsetParent(element1, getRoot(element2).host);
295  }
296}
297
298/**
299 * Gets the scroll value of the given element in the given side (top and left)
300 * @method
301 * @memberof Popper.Utils
302 * @argument {Element} element
303 * @argument {String} side `top` or `left`
304 * @returns {number} amount of scrolled pixels
305 */
306function getScroll(element) {
307  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
308
309  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
310  var nodeName = element.nodeName;
311
312  if (nodeName === 'BODY' || nodeName === 'HTML') {
313    var html = element.ownerDocument.documentElement;
314    var scrollingElement = element.ownerDocument.scrollingElement || html;
315    return scrollingElement[upperSide];
316  }
317
318  return element[upperSide];
319}
320
321/*
322 * Sum or subtract the element scroll values (left and top) from a given rect object
323 * @method
324 * @memberof Popper.Utils
325 * @param {Object} rect - Rect object you want to change
326 * @param {HTMLElement} element - The element from the function reads the scroll values
327 * @param {Boolean} subtract - set to true if you want to subtract the scroll values
328 * @return {Object} rect - The modifier rect object
329 */
330function includeScroll(rect, element) {
331  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
332
333  var scrollTop = getScroll(element, 'top');
334  var scrollLeft = getScroll(element, 'left');
335  var modifier = subtract ? -1 : 1;
336  rect.top += scrollTop * modifier;
337  rect.bottom += scrollTop * modifier;
338  rect.left += scrollLeft * modifier;
339  rect.right += scrollLeft * modifier;
340  return rect;
341}
342
343/*
344 * Helper to detect borders of a given element
345 * @method
346 * @memberof Popper.Utils
347 * @param {CSSStyleDeclaration} styles
348 * Result of `getStyleComputedProperty` on the given element
349 * @param {String} axis - `x` or `y`
350 * @return {number} borders - The borders size of the given axis
351 */
352
353function getBordersSize(styles, axis) {
354  var sideA = axis === 'x' ? 'Left' : 'Top';
355  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
356
357  return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);
358}
359
360function getSize(axis, body, html, computedStyle) {
361  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);
362}
363
364function getWindowSizes(document) {
365  var body = document.body;
366  var html = document.documentElement;
367  var computedStyle = isIE(10) && getComputedStyle(html);
368
369  return {
370    height: getSize('Height', body, html, computedStyle),
371    width: getSize('Width', body, html, computedStyle)
372  };
373}
374
375var classCallCheck = function (instance, Constructor) {
376  if (!(instance instanceof Constructor)) {
377    throw new TypeError("Cannot call a class as a function");
378  }
379};
380
381var createClass = function () {
382  function defineProperties(target, props) {
383    for (var i = 0; i < props.length; i++) {
384      var descriptor = props[i];
385      descriptor.enumerable = descriptor.enumerable || false;
386      descriptor.configurable = true;
387      if ("value" in descriptor) descriptor.writable = true;
388      Object.defineProperty(target, descriptor.key, descriptor);
389    }
390  }
391
392  return function (Constructor, protoProps, staticProps) {
393    if (protoProps) defineProperties(Constructor.prototype, protoProps);
394    if (staticProps) defineProperties(Constructor, staticProps);
395    return Constructor;
396  };
397}();
398
399
400
401
402
403var defineProperty = function (obj, key, value) {
404  if (key in obj) {
405    Object.defineProperty(obj, key, {
406      value: value,
407      enumerable: true,
408      configurable: true,
409      writable: true
410    });
411  } else {
412    obj[key] = value;
413  }
414
415  return obj;
416};
417
418var _extends = Object.assign || function (target) {
419  for (var i = 1; i < arguments.length; i++) {
420    var source = arguments[i];
421
422    for (var key in source) {
423      if (Object.prototype.hasOwnProperty.call(source, key)) {
424        target[key] = source[key];
425      }
426    }
427  }
428
429  return target;
430};
431
432/**
433 * Given element offsets, generate an output similar to getBoundingClientRect
434 * @method
435 * @memberof Popper.Utils
436 * @argument {Object} offsets
437 * @returns {Object} ClientRect like output
438 */
439function getClientRect(offsets) {
440  return _extends({}, offsets, {
441    right: offsets.left + offsets.width,
442    bottom: offsets.top + offsets.height
443  });
444}
445
446/**
447 * Get bounding client rect of given element
448 * @method
449 * @memberof Popper.Utils
450 * @param {HTMLElement} element
451 * @return {Object} client rect
452 */
453function getBoundingClientRect(element) {
454  var rect = {};
455
456  // IE10 10 FIX: Please, don't ask, the element isn't

457  // considered in DOM in some circumstances...
458  // This isn't reproducible in IE10 compatibility mode of IE11
459  try {
460    if (isIE(10)) {
461      rect = element.getBoundingClientRect();
462      var scrollTop = getScroll(element, 'top');
463      var scrollLeft = getScroll(element, 'left');
464      rect.top += scrollTop;
465      rect.left += scrollLeft;
466      rect.bottom += scrollTop;
467      rect.right += scrollLeft;
468    } else {
469      rect = element.getBoundingClientRect();
470    }
471  } catch (e) {}
472
473  var result = {
474    left: rect.left,
475    top: rect.top,
476    width: rect.right - rect.left,
477    height: rect.bottom - rect.top
478  };
479
480  // subtract scrollbar size from sizes
481  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
482  var width = sizes.width || element.clientWidth || result.width;
483  var height = sizes.height || element.clientHeight || result.height;
484
485  var horizScrollbar = element.offsetWidth - width;
486  var vertScrollbar = element.offsetHeight - height;
487
488  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
489  // we make this check conditional for performance reasons
490  if (horizScrollbar || vertScrollbar) {
491    var styles = getStyleComputedProperty(element);
492    horizScrollbar -= getBordersSize(styles, 'x');
493    vertScrollbar -= getBordersSize(styles, 'y');
494
495    result.width -= horizScrollbar;
496    result.height -= vertScrollbar;
497  }
498
499  return getClientRect(result);
500}
501
502function getOffsetRectRelativeToArbitraryNode(children, parent) {
503  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
504
505  var isIE10 = isIE(10);
506  var isHTML = parent.nodeName === 'HTML';
507  var childrenRect = getBoundingClientRect(children);
508  var parentRect = getBoundingClientRect(parent);
509  var scrollParent = getScrollParent(children);
510
511  var styles = getStyleComputedProperty(parent);
512  var borderTopWidth = parseFloat(styles.borderTopWidth);
513  var borderLeftWidth = parseFloat(styles.borderLeftWidth);
514
515  // In cases where the parent is fixed, we must ignore negative scroll in offset calc
516  if (fixedPosition && isHTML) {
517    parentRect.top = Math.max(parentRect.top, 0);
518    parentRect.left = Math.max(parentRect.left, 0);
519  }
520  var offsets = getClientRect({
521    top: childrenRect.top - parentRect.top - borderTopWidth,
522    left: childrenRect.left - parentRect.left - borderLeftWidth,
523    width: childrenRect.width,
524    height: childrenRect.height
525  });
526  offsets.marginTop = 0;
527  offsets.marginLeft = 0;
528
529  // Subtract margins of documentElement in case it's being used as parent
530  // we do this only on HTML because it's the only element that behaves
531  // differently when margins are applied to it. The margins are included in
532  // the box of the documentElement, in the other cases not.
533  if (!isIE10 && isHTML) {
534    var marginTop = parseFloat(styles.marginTop);
535    var marginLeft = parseFloat(styles.marginLeft);
536
537    offsets.top -= borderTopWidth - marginTop;
538    offsets.bottom -= borderTopWidth - marginTop;
539    offsets.left -= borderLeftWidth - marginLeft;
540    offsets.right -= borderLeftWidth - marginLeft;
541
542    // Attach marginTop and marginLeft because in some circumstances we may need them
543    offsets.marginTop = marginTop;
544    offsets.marginLeft = marginLeft;
545  }
546
547  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
548    offsets = includeScroll(offsets, parent);
549  }
550
551  return offsets;
552}
553
554function getViewportOffsetRectRelativeToArtbitraryNode(element) {
555  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
556
557  var html = element.ownerDocument.documentElement;
558  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
559  var width = Math.max(html.clientWidth, window.innerWidth || 0);
560  var height = Math.max(html.clientHeight, window.innerHeight || 0);
561
562  var scrollTop = !excludeScroll ? getScroll(html) : 0;
563  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
564
565  var offset = {
566    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
567    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
568    width: width,
569    height: height
570  };
571
572  return getClientRect(offset);
573}
574
575/**
576 * Check if the given element is fixed or is inside a fixed parent
577 * @method
578 * @memberof Popper.Utils
579 * @argument {Element} element
580 * @argument {Element} customContainer
581 * @returns {Boolean} answer to "isFixed?"
582 */
583function isFixed(element) {
584  var nodeName = element.nodeName;
585  if (nodeName === 'BODY' || nodeName === 'HTML') {
586    return false;

587  }
588  if (getStyleComputedProperty(element, 'position') === 'fixed') {
589    return true;
590  }
591  var parentNode = getParentNode(element);
592  if (!parentNode) {
593    return false;
594  }
595  return isFixed(parentNode);
596}
597
598/**
599 * Finds the first parent of an element that has a transformed property defined
600 * @method
601 * @memberof Popper.Utils
602 * @argument {Element} element
603 * @returns {Element} first transformed parent or documentElement
604 */
605
606function getFixedPositionOffsetParent(element) {
607  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
608  if (!element || !element.parentElement || isIE()) {
609    return document.documentElement;
610  }
611  var el = element.parentElement;
612  while (el && getStyleComputedProperty(el, 'transform') === 'none') {
613    el = el.parentElement;
614  }
615  return el || document.documentElement;
616}
617
618/**
619 * Computed the boundaries limits and return them
620 * @method
621 * @memberof Popper.Utils
622 * @param {HTMLElement} popper
623 * @param {HTMLElement} reference
624 * @param {number} padding
625 * @param {HTMLElement} boundariesElement - Element used to define the boundaries
626 * @param {Boolean} fixedPosition - Is in fixed position mode
627 * @returns {Object} Coordinates of the boundaries
628 */
629function getBoundaries(popper, reference, padding, boundariesElement) {
630  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
631
632  // NOTE: 1 DOM access here
633
634  var boundaries = { top: 0, left: 0 };
635  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
636
637  // Handle viewport case
638  if (boundariesElement === 'viewport') {
639    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
640  } else {
641    // Handle other cases based on DOM element used as boundaries
642    var boundariesNode = void 0;
643    if (boundariesElement === 'scrollParent') {
644      boundariesNode = getScrollParent(getParentNode(reference));
645      if (boundariesNode.nodeName === 'BODY') {
646        boundariesNode = popper.ownerDocument.documentElement;
647      }
648    } else if (boundariesElement === 'window') {
649      boundariesNode = popper.ownerDocument.documentElement;
650    } else {
651      boundariesNode = boundariesElement;
652    }
653
654    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
655
656    // In case of HTML, we need a different computation
657    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
658      var _getWindowSizes = getWindowSizes(popper.ownerDocument),
659          height = _getWindowSizes.height,
660          width = _getWindowSizes.width;
661
662      boundaries.top += offsets.top - offsets.marginTop;
663      boundaries.bottom = height + offsets.top;
664      boundaries.left += offsets.left - offsets.marginLeft;
665      boundaries.right = width + offsets.left;
666    } else {
667      // for all the other DOM elements, this one is good
668      boundaries = offsets;
669    }
670  }
671
672  // Add paddings
673  padding = padding || 0;
674  var isPaddingNumber = typeof padding === 'number';
675  boundaries.left += isPaddingNumber ? padding : padding.left || 0;
676  boundaries.top += isPaddingNumber ? padding : padding.top || 0;
677  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
678  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
679
680  return boundaries;
681}
682
683function getArea(_ref) {
684  var width = _ref.width,
685      height = _ref.height;
686
687  return width * height;
688}
689
690/**
691 * Utility used to transform the `auto` placement to the placement with more
692 * available space.
693 * @method
694 * @memberof Popper.Utils
695 * @argument {Object} data - The data object generated by update method
696 * @argument {Object} options - Modifiers configuration and options
697 * @returns {Object} The data object, properly modified
698 */
699function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
700  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
701
702  if (placement.indexOf('auto') === -1) {
703    return placement;
704  }
705
706  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
707
708  var rects = {
709    top: {
710      width: boundaries.width,
711      height: refRect.top - boundaries.top
712    },
713    right: {
714      width: boundaries.right - refRect.right,
715      height: boundaries.height
716    },
717    bottom: {
718      width: boundaries.width,
719      height: boundaries.bottom - refRect.bottom
720    },
721    left: {
722      width: refRect.left - boundaries.left,
723      height: boundaries.height
724    }
725  };
726
727  var sortedAreas = Object.keys(rects).map(function (key) {
728    return _extends({
729      key: key
730    }, rects[key], {
731      area: getArea(rects[key])
732    });
733  }).sort(function (a, b) {
734    return b.area - a.area;
735  });
736
737  var filteredAreas = sortedAreas.filter(function (_ref2) {
738    var width = _ref2.width,
739        height = _ref2.height;
740    return width >= popper.clientWidth && height >= popper.clientHeight;
741  });
742
743  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
744
745  var variation = placement.split('-')[1];
746
747  return computedPlacement + (variation ? '-' + variation : '');
748}
749
750/**
751 * Get offsets to the reference element
752 * @method
753 * @memberof Popper.Utils
754 * @param {Object} state
755 * @param {Element} popper - the popper element
756 * @param {Element} reference - the reference element (the popper will be relative to this)
757 * @param {Element} fixedPosition - is in fixed position mode
758 * @returns {Object} An object containing the offsets which will be applied to the popper
759 */
760function getReferenceOffsets(state, popper, reference) {
761  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
762
763  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
764  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
765}
766
767/**
768 * Get the outer sizes of the given element (offset size + margins)
769 * @method
770 * @memberof Popper.Utils
771 * @argument {Element} element
772 * @returns {Object} object containing width and height properties
773 */
774function getOuterSizes(element) {
775  var window = element.ownerDocument.defaultView;
776  var styles = window.getComputedStyle(element);
777  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
778  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
779  var result = {
780    width: element.offsetWidth + y,
781    height: element.offsetHeight + x
782  };
783  return result;
784}
785
786/**
787 * Get the opposite placement of the given one
788 * @method
789 * @memberof Popper.Utils
790 * @argument {String} placement
791 * @returns {String} flipped placement
792 */
793function getOppositePlacement(placement) {
794  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
795  return placement.replace(/left|right|bottom|top/g, function (matched) {
796    return hash[matched];
797  });
798}
799
800/**
801 * Get offsets to the popper
802 * @method
803 * @memberof Popper.Utils
804 * @param {Object} position - CSS position the Popper will get applied
805 * @param {HTMLElement} popper - the popper element
806 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
807 * @param {String} placement - one of the valid placement options
808 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
809 */
810function getPopperOffsets(popper, referenceOffsets, placement) {
811  placement = placement.split('-')[0];
812
813  // Get popper node sizes
814  var popperRect = getOuterSizes(popper);
815
816  // Add position, width and height to our offsets object
817  var popperOffsets = {
818    width: popperRect.width,
819    height: popperRect.height
820  };
821
822  // depending by the popper placement we have to compute its offsets slightly differently
823  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
824  var mainSide = isHoriz ? 'top' : 'left';
825  var secondarySide = isHoriz ? 'left' : 'top';
826  var measurement = isHoriz ? 'height' : 'width';
827  var secondaryMeasurement = !isHoriz ? 'height' : 'width';
828
829  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
830  if (placement === secondarySide) {
831    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
832  } else {
833    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
834  }
835
836  return popperOffsets;
837}
838
839/**
840 * Mimics the `find` method of Array
841 * @method
842 * @memberof Popper.Utils
843 * @argument {Array} arr
844 * @argument prop
845 * @argument value
846 * @returns index or -1
847 */
848function find(arr, check) {
849  // use native find if supported
850  if (Array.prototype.find) {
851    return arr.find(check);
852  }
853
854  // use `filter` to obtain the same behavior of `find`
855  return arr.filter(check)[0];
856}
857
858/**
859 * Return the index of the matching object
860 * @method
861 * @memberof Popper.Utils
862 * @argument {Array} arr
863 * @argument prop
864 * @argument value
865 * @returns index or -1
866 */
867function findIndex(arr, prop, value) {
868  // use native findIndex if supported
869  if (Array.prototype.findIndex) {
870    return arr.findIndex(function (cur) {
871      return cur[prop] === value;
872    });
873  }
874
875  // use `find` + `indexOf` if `findIndex` isn't supported
876  var match = find(arr, function (obj) {
877    return obj[prop] === value;
878  });
879  return arr.indexOf(match);
880}
881
882/**
883 * Loop trough the list of modifiers and run them in order,
884 * each of them will then edit the data object.
885 * @method
886 * @memberof Popper.Utils
887 * @param {dataObject} data
888 * @param {Array} modifiers
889 * @param {String} ends - Optional modifier name used as stopper
890 * @returns {dataObject}
891 */
892function runModifiers(modifiers, data, ends) {
893  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
894
895  modifiersToRun.forEach(function (modifier) {
896    if (modifier['function']) {
897      // eslint-disable-line dot-notation
898      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
899    }
900    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
901    if (modifier.enabled && isFunction(fn)) {
902      // Add properties to offsets to make them a complete clientRect object
903      // we do this before each modifier to make sure the previous one doesn't
904      // mess with these values
905      data.offsets.popper = getClientRect(data.offsets.popper);
906      data.offsets.reference = getClientRect(data.offsets.reference);
907
908      data = fn(data, modifier);
909    }
910  });
911
912  return data;
913}
914
915/**
916 * Updates the position of the popper, computing the new offsets and applying
917 * the new style.<br />
918 * Prefer `scheduleUpdate` over `update` because of performance reasons.
919 * @method
920 * @memberof Popper
921 */
922function update() {
923  // if popper is destroyed, don't perform any further update
924  if (this.state.isDestroyed) {
925    return;
926  }
927
928  var data = {
929    instance: this,
930    styles: {},
931    arrowStyles: {},
932    attributes: {},
933    flipped: false,
934    offsets: {}
935  };
936
937  // compute reference element offsets
938  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
939
940  // compute auto placement, store placement inside the data object,
941  // modifiers will be able to edit `placement` if needed
942  // and refer to originalPlacement to know the original value
943  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
944
945  // store the computed placement inside `originalPlacement`
946  data.originalPlacement = data.placement;
947
948  data.positionFixed = this.options.positionFixed;
949
950  // compute the popper offsets
951  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
952
953  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
954
955  // run the modifiers
956  data = runModifiers(this.modifiers, data);
957
958  // the first `update` will call `onCreate` callback
959  // the other ones will call `onUpdate` callback
960  if (!this.state.isCreated) {
961    this.state.isCreated = true;
962    this.options.onCreate(data);
963  } else {
964    this.options.onUpdate(data);
965  }
966}
967
968/**
969 * Helper used to know if the given modifier is enabled.
970 * @method
971 * @memberof Popper.Utils
972 * @returns {Boolean}
973 */
974function isModifierEnabled(modifiers, modifierName) {
975  return modifiers.some(function (_ref) {
976    var name = _ref.name,
977        enabled = _ref.enabled;
978    return enabled && name === modifierName;
979  });
980}
981
982/**
983 * Get the prefixed supported property name
984 * @method
985 * @memberof Popper.Utils
986 * @argument {String} property (camelCase)
987 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
988 */
989function getSupportedPropertyName(property) {
990  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
991  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
992
993  for (var i = 0; i < prefixes.length; i++) {
994    var prefix = prefixes[i];
995    var toCheck = prefix ? '' + prefix + upperProp : property;
996    if (typeof document.body.style[toCheck] !== 'undefined') {
997      return toCheck;
998    }
999  }
1000  return null;
1001}
1002
1003/**
1004 * Destroys the popper.
1005 * @method
1006 * @memberof Popper
1007 */
1008function destroy() {
1009  this.state.isDestroyed = true;
1010
1011  // touch DOM only if `applyStyle` modifier is enabled
1012  if (isModifierEnabled(this.modifiers, 'applyStyle')) {
1013    this.popper.removeAttribute('x-placement');
1014    this.popper.style.position = '';
1015    this.popper.style.top = '';
1016    this.popper.style.left = '';
1017    this.popper.style.right = '';
1018    this.popper.style.bottom = '';
1019    this.popper.style.willChange = '';
1020    this.popper.style[getSupportedPropertyName('transform')] = '';
1021  }
1022
1023  this.disableEventListeners();
1024
1025  // remove the popper if user explicitly asked for the deletion on destroy
1026  // do not use `remove` because IE11 doesn't support it
1027  if (this.options.removeOnDestroy) {
1028    this.popper.parentNode.removeChild(this.popper);
1029  }
1030  return this;
1031}
1032
1033/**
1034 * Get the window associated with the element
1035 * @argument {Element} element
1036 * @returns {Window}
1037 */
1038function getWindow(element) {
1039  var ownerDocument = element.ownerDocument;
1040  return ownerDocument ? ownerDocument.defaultView : window;
1041}
1042
1043function attachToScrollParents(scrollParent, event, callback, scrollParents) {
1044  var isBody = scrollParent.nodeName === 'BODY';
1045  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
1046  target.addEventListener(event, callback, { passive: true });
1047
1048  if (!isBody) {
1049    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
1050  }
1051  scrollParents.push(target);
1052}
1053
1054/**
1055 * Setup needed event listeners used to update the popper position
1056 * @method
1057 * @memberof Popper.Utils
1058 * @private
1059 */
1060function setupEventListeners(reference, options, state, updateBound) {
1061  // Resize event listener on window
1062  state.updateBound = updateBound;
1063  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
1064
1065  // Scroll event listener on scroll parents
1066  var scrollElement = getScrollParent(reference);
1067  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
1068  state.scrollElement = scrollElement;
1069  state.eventsEnabled = true;
1070
1071  return state;
1072}
1073
1074/**
1075 * It will add resize/scroll events and start recalculating
1076 * position of the popper element when they are triggered.
1077 * @method
1078 * @memberof Popper
1079 */
1080function enableEventListeners() {
1081  if (!this.state.eventsEnabled) {
1082    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
1083  }
1084}
1085
1086/**
1087 * Remove event listeners used to update the popper position
1088 * @method
1089 * @memberof Popper.Utils
1090 * @private
1091 */
1092function removeEventListeners(reference, state) {
1093  // Remove resize event listener on window
1094  getWindow(reference).removeEventListener('resize', state.updateBound);
1095
1096  // Remove scroll event listener on scroll parents
1097  state.scrollParents.forEach(function (target) {
1098    target.removeEventListener('scroll', state.updateBound);
1099  });
1100
1101  // Reset state
1102  state.updateBound = null;
1103  state.scrollParents = [];
1104  state.scrollElement = null;
1105  state.eventsEnabled = false;
1106  return state;
1107}
1108
1109/**
1110 * It will remove resize/scroll events and won't recalculate popper position
1111 * when they are triggered. It also won't trigger `onUpdate` callback anymore,
1112 * unless you call `update` method manually.
1113 * @method
1114 * @memberof Popper
1115 */
1116function disableEventListeners() {
1117  if (this.state.eventsEnabled) {
1118    cancelAnimationFrame(this.scheduleUpdate);
1119    this.state = removeEventListeners(this.reference, this.state);
1120  }
1121}
1122
1123/**
1124 * Tells if a given input is a number
1125 * @method
1126 * @memberof Popper.Utils
1127 * @param {*} input to check
1128 * @return {Boolean}
1129 */
1130function isNumeric(n) {
1131  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
1132}
1133
1134/**
1135 * Set the style to the given popper
1136 * @method
1137 * @memberof Popper.Utils
1138 * @argument {Element} element - Element to apply the style to
1139 * @argument {Object} styles
1140 * Object with a list of properties and values which will be applied to the element
1141 */
1142function setStyles(element, styles) {
1143  Object.keys(styles).forEach(function (prop) {
1144    var unit = '';
1145    // add unit if the value is numeric and is one of the following
1146    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
1147      unit = 'px';
1148    }
1149    element.style[prop] = styles[prop] + unit;
1150  });
1151}
1152
1153/**
1154 * Set the attributes to the given popper
1155 * @method
1156 * @memberof Popper.Utils
1157 * @argument {Element} element - Element to apply the attributes to
1158 * @argument {Object} styles
1159 * Object with a list of properties and values which will be applied to the element
1160 */
1161function setAttributes(element, attributes) {
1162  Object.keys(attributes).forEach(function (prop) {
1163    var value = attributes[prop];
1164    if (value !== false) {
1165      element.setAttribute(prop, attributes[prop]);
1166    } else {
1167      element.removeAttribute(prop);
1168    }
1169  });
1170}
1171
1172/**
1173 * @function
1174 * @memberof Modifiers
1175 * @argument {Object} data - The data object generated by `update` method
1176 * @argument {Object} data.styles - List of style properties - values to apply to popper element
1177 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
1178 * @argument {Object} options - Modifiers configuration and options
1179 * @returns {Object} The same data object
1180 */
1181function applyStyle(data) {
1182  // any property present in `data.styles` will be applied to the popper,
1183  // in this way we can make the 3rd party modifiers add custom styles to it
1184  // Be aware, modifiers could override the properties defined in the previous
1185  // lines of this modifier!
1186  setStyles(data.instance.popper, data.styles);
1187
1188  // any property present in `data.attributes` will be applied to the popper,
1189  // they will be set as HTML attributes of the element
1190  setAttributes(data.instance.popper, data.attributes);
1191
1192  // if arrowElement is defined and arrowStyles has some properties
1193  if (data.arrowElement && Object.keys(data.arrowStyles).length) {
1194    setStyles(data.arrowElement, data.arrowStyles);
1195  }
1196
1197  return data;
1198}
1199
1200/**
1201 * Set the x-placement attribute before everything else because it could be used
1202 * to add margins to the popper margins needs to be calculated to get the
1203 * correct popper offsets.
1204 * @method
1205 * @memberof Popper.modifiers
1206 * @param {HTMLElement} reference - The reference element used to position the popper
1207 * @param {HTMLElement} popper - The HTML element used as popper
1208 * @param {Object} options - Popper.js options
1209 */
1210function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
1211  // compute reference element offsets
1212  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
1213
1214  // compute auto placement, store placement inside the data object,
1215  // modifiers will be able to edit `placement` if needed
1216  // and refer to originalPlacement to know the original value
1217  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
1218
1219  popper.setAttribute('x-placement', placement);
1220
1221  // Apply `position` to popper before anything else because
1222  // without the position applied we can't guarantee correct computations
1223  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
1224
1225  return options;
1226}
1227
1228/**
1229 * @function
1230 * @memberof Popper.Utils
1231 * @argument {Object} data - The data object generated by `update` method
1232 * @argument {Boolean} shouldRound - If the offsets should be rounded at all
1233 * @returns {Object} The popper's position offsets rounded
1234 *
1235 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
1236 * good as it can be within reason.
1237 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
1238 *
1239 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
1240 * as well on High DPI screens).
1241 *
1242 * Firefox prefers no rounding for positioning and does not have blurriness on
1243 * high DPI screens.
1244 *
1245 * Only horizontal placement and left/right values need to be considered.
1246 */
1247function getRoundedOffsets(data, shouldRound) {
1248  var _data$offsets = data.offsets,
1249      popper = _data$offsets.popper,
1250      reference = _data$offsets.reference;
1251  var round = Math.round,
1252      floor = Math.floor;
1253
1254  var noRound = function noRound(v) {
1255    return v;
1256  };
1257
1258  var referenceWidth = round(reference.width);
1259  var popperWidth = round(popper.width);
1260
1261  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
1262  var isVariation = data.placement.indexOf('-') !== -1;
1263  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
1264  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
1265
1266  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
1267  var verticalToInteger = !shouldRound ? noRound : round;
1268
1269  return {
1270    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
1271    top: verticalToInteger(popper.top),
1272    bottom: verticalToInteger(popper.bottom),
1273    right: horizontalToInteger(popper.right)
1274  };
1275}
1276
1277var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
1278
1279/**
1280 * @function
1281 * @memberof Modifiers
1282 * @argument {Object} data - The data object generated by `update` method
1283 * @argument {Object} options - Modifiers configuration and options
1284 * @returns {Object} The data object, properly modified
1285 */
1286function computeStyle(data, options) {
1287  var x = options.x,
1288      y = options.y;
1289  var popper = data.offsets.popper;
1290
1291  // Remove this legacy support in Popper.js v2
1292
1293  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
1294    return modifier.name === 'applyStyle';
1295  }).gpuAcceleration;
1296  if (legacyGpuAccelerationOption !== undefined) {
1297    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
1298  }
1299  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
1300
1301  var offsetParent = getOffsetParent(data.instance.popper);
1302  var offsetParentRect = getBoundingClientRect(offsetParent);
1303
1304  // Styles
1305  var styles = {
1306    position: popper.position
1307  };
1308
1309  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
1310
1311  var sideA = x === 'bottom' ? 'top' : 'bottom';
1312  var sideB = y === 'right' ? 'left' : 'right';
1313
1314  // if gpuAcceleration is set to `true` and transform is supported,
1315  //  we use `translate3d` to apply the position to the popper we
1316  // automatically use the supported prefixed version if needed
1317  var prefixedProperty = getSupportedPropertyName('transform');
1318
1319  // now, let's make a step back and look at this code closely (wtf?)
1320  // If the content of the popper grows once it's been positioned, it
1321  // may happen that the popper gets misplaced because of the new content
1322  // overflowing its reference element
1323  // To avoid this problem, we provide two options (x and y), which allow
1324  // the consumer to define the offset origin.
1325  // If we position a popper on top of a reference element, we can set
1326  // `x` to `top` to make the popper grow towards its top instead of
1327  // its bottom.
1328  var left = void 0,
1329      top = void 0;
1330  if (sideA === 'bottom') {
1331    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
1332    // and not the bottom of the html element
1333    if (offsetParent.nodeName === 'HTML') {
1334      top = -offsetParent.clientHeight + offsets.bottom;
1335    } else {
1336      top = -offsetParentRect.height + offsets.bottom;
1337    }
1338  } else {
1339    top = offsets.top;
1340  }
1341  if (sideB === 'right') {
1342    if (offsetParent.nodeName === 'HTML') {
1343      left = -offsetParent.clientWidth + offsets.right;
1344    } else {
1345      left = -offsetParentRect.width + offsets.right;
1346    }
1347  } else {
1348    left = offsets.left;
1349  }
1350  if (gpuAcceleration && prefixedProperty) {
1351    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
1352    styles[sideA] = 0;
1353    styles[sideB] = 0;
1354    styles.willChange = 'transform';
1355  } else {
1356    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
1357    var invertTop = sideA === 'bottom' ? -1 : 1;
1358    var invertLeft = sideB === 'right' ? -1 : 1;
1359    styles[sideA] = top * invertTop;
1360    styles[sideB] = left * invertLeft;
1361    styles.willChange = sideA + ', ' + sideB;
1362  }
1363
1364  // Attributes
1365  var attributes = {
1366    'x-placement': data.placement
1367  };
1368
1369  // Update `data` attributes, styles and arrowStyles
1370  data.attributes = _extends({}, attributes, data.attributes);
1371  data.styles = _extends({}, styles, data.styles);
1372  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
1373
1374  return data;
1375}
1376
1377/**
1378 * Helper used to know if the given modifier depends from another one.<br />
1379 * It checks if the needed modifier is listed and enabled.
1380 * @method
1381 * @memberof Popper.Utils
1382 * @param {Array} modifiers - list of modifiers
1383 * @param {String} requestingName - name of requesting modifier
1384 * @param {String} requestedName - name of requested modifier
1385 * @returns {Boolean}
1386 */
1387function isModifierRequired(modifiers, requestingName, requestedName) {
1388  var requesting = find(modifiers, function (_ref) {
1389    var name = _ref.name;
1390    return name === requestingName;
1391  });
1392
1393  var isRequired = !!requesting && modifiers.some(function (modifier) {
1394    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
1395  });
1396
1397  if (!isRequired) {
1398    var _requesting = '`' + requestingName + '`';
1399    var requested = '`' + requestedName + '`';
1400    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
1401  }
1402  return isRequired;
1403}
1404
1405/**
1406 * @function
1407 * @memberof Modifiers
1408 * @argument {Object} data - The data object generated by update method
1409 * @argument {Object} options - Modifiers configuration and options
1410 * @returns {Object} The data object, properly modified
1411 */
1412function arrow(data, options) {
1413  var _data$offsets$arrow;
1414
1415  // arrow depends on keepTogether in order to work
1416  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
1417    return data;
1418  }
1419
1420  var arrowElement = options.element;
1421
1422  // if arrowElement is a string, suppose it's a CSS selector
1423  if (typeof arrowElement === 'string') {
1424    arrowElement = data.instance.popper.querySelector(arrowElement);
1425
1426    // if arrowElement is not found, don't run the modifier
1427    if (!arrowElement) {
1428      return data;
1429    }
1430  } else {
1431    // if the arrowElement isn't a query selector we must check that the
1432    // provided DOM node is child of its popper node
1433    if (!data.instance.popper.contains(arrowElement)) {
1434      console.warn('WARNING: `arrow.element` must be child of its popper element!');
1435      return data;
1436    }
1437  }
1438
1439  var placement = data.placement.split('-')[0];
1440  var _data$offsets = data.offsets,
1441      popper = _data$offsets.popper,
1442      reference = _data$offsets.reference;
1443
1444  var isVertical = ['left', 'right'].indexOf(placement) !== -1;
1445
1446  var len = isVertical ? 'height' : 'width';
1447  var sideCapitalized = isVertical ? 'Top' : 'Left';
1448  var side = sideCapitalized.toLowerCase();
1449  var altSide = isVertical ? 'left' : 'top';
1450  var opSide = isVertical ? 'bottom' : 'right';
1451  var arrowElementSize = getOuterSizes(arrowElement)[len];
1452
1453  //
1454  // extends keepTogether behavior making sure the popper and its
1455  // reference have enough pixels in conjunction
1456  //
1457
1458  // top/left side
1459  if (reference[opSide] - arrowElementSize < popper[side]) {
1460    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
1461  }
1462  // bottom/right side
1463  if (reference[side] + arrowElementSize > popper[opSide]) {
1464    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
1465  }
1466  data.offsets.popper = getClientRect(data.offsets.popper);
1467
1468  // compute center of the popper
1469  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
1470
1471  // Compute the sideValue using the updated popper offsets
1472  // take popper margin in account because we don't have this info available
1473  var css = getStyleComputedProperty(data.instance.popper);
1474  var popperMarginSide = parseFloat(css['margin' + sideCapitalized]);
1475  var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']);
1476  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
1477
1478  // prevent arrowElement from being placed not contiguously to its popper
1479  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
1480
1481  data.arrowElement = arrowElement;
1482  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
1483
1484  return data;
1485}
1486
1487/**
1488 * Get the opposite placement variation of the given one
1489 * @method
1490 * @memberof Popper.Utils
1491 * @argument {String} placement variation
1492 * @returns {String} flipped placement variation
1493 */
1494function getOppositeVariation(variation) {
1495  if (variation === 'end') {
1496    return 'start';
1497  } else if (variation === 'start') {
1498    return 'end';
1499  }
1500  return variation;
1501}
1502
1503/**
1504 * List of accepted placements to use as values of the `placement` option.<br />
1505 * Valid placements are:
1506 * - `auto`
1507 * - `top`
1508 * - `right`
1509 * - `bottom`
1510 * - `left`
1511 *
1512 * Each placement can have a variation from this list:
1513 * - `-start`
1514 * - `-end`
1515 *
1516 * Variations are interpreted easily if you think of them as the left to right
1517 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
1518 * is right.<br />
1519 * Vertically (`left` and `right`), `start` is top and `end` is bottom.
1520 *
1521 * Some valid examples are:
1522 * - `top-end` (on top of reference, right aligned)
1523 * - `right-start` (on right of reference, top aligned)
1524 * - `bottom` (on bottom, centered)
1525 * - `auto-end` (on the side with more space available, alignment depends by placement)
1526 *
1527 * @static
1528 * @type {Array}
1529 * @enum {String}
1530 * @readonly
1531 * @method placements
1532 * @memberof Popper
1533 */
1534var 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'];
1535
1536// Get rid of `auto` `auto-start` and `auto-end`
1537var validPlacements = placements.slice(3);
1538
1539/**
1540 * Given an initial placement, returns all the subsequent placements
1541 * clockwise (or counter-clockwise).
1542 *
1543 * @method
1544 * @memberof Popper.Utils
1545 * @argument {String} placement - A valid placement (it accepts variations)
1546 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
1547 * @returns {Array} placements including their variations
1548 */
1549function clockwise(placement) {
1550  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1551
1552  var index = validPlacements.indexOf(placement);
1553  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
1554  return counter ? arr.reverse() : arr;
1555}
1556
1557var BEHAVIORS = {
1558  FLIP: 'flip',
1559  CLOCKWISE: 'clockwise',
1560  COUNTERCLOCKWISE: 'counterclockwise'
1561};
1562
1563/**
1564 * @function
1565 * @memberof Modifiers
1566 * @argument {Object} data - The data object generated by update method
1567 * @argument {Object} options - Modifiers configuration and options
1568 * @returns {Object} The data object, properly modified
1569 */
1570function flip(data, options) {
1571  // if `inner` modifier is enabled, we can't use the `flip` modifier
1572  if (isModifierEnabled(data.instance.modifiers, 'inner')) {
1573    return data;
1574  }
1575
1576  if (data.flipped && data.placement === data.originalPlacement) {
1577    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
1578    return data;
1579  }
1580
1581  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
1582
1583  var placement = data.placement.split('-')[0];
1584  var placementOpposite = getOppositePlacement(placement);
1585  var variation = data.placement.split('-')[1] || '';
1586
1587  var flipOrder = [];
1588
1589  switch (options.behavior) {
1590    case BEHAVIORS.FLIP:
1591      flipOrder = [placement, placementOpposite];
1592      break;
1593    case BEHAVIORS.CLOCKWISE:
1594      flipOrder = clockwise(placement);
1595      break;
1596    case BEHAVIORS.COUNTERCLOCKWISE:
1597      flipOrder = clockwise(placement, true);
1598      break;
1599    default:
1600      flipOrder = options.behavior;
1601  }
1602
1603  flipOrder.forEach(function (step, index) {
1604    if (placement !== step || flipOrder.length === index + 1) {
1605      return data;
1606    }
1607
1608    placement = data.placement.split('-')[0];
1609    placementOpposite = getOppositePlacement(placement);
1610
1611    var popperOffsets = data.offsets.popper;
1612    var refOffsets = data.offsets.reference;
1613
1614    // using floor because the reference offsets may contain decimals we are not going to consider here
1615    var floor = Math.floor;
1616    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);
1617
1618    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
1619    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
1620    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
1621    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
1622
1623    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
1624
1625    // flip the variation if required
1626    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1627
1628    // flips variation if reference element overflows boundaries
1629    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
1630
1631    // flips variation if popper content overflows boundaries
1632    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
1633
1634    var flippedVariation = flippedVariationByRef || flippedVariationByContent;
1635
1636    if (overlapsRef || overflowsBoundaries || flippedVariation) {
1637      // this boolean to detect any flip loop
1638      data.flipped = true;
1639
1640      if (overlapsRef || overflowsBoundaries) {
1641        placement = flipOrder[index + 1];
1642      }
1643
1644      if (flippedVariation) {
1645        variation = getOppositeVariation(variation);
1646      }
1647
1648      data.placement = placement + (variation ? '-' + variation : '');
1649
1650      // this object contains `position`, we want to preserve it along with
1651      // any additional property we may add in the future
1652      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
1653
1654      data = runModifiers(data.instance.modifiers, data, 'flip');
1655    }
1656  });
1657  return data;
1658}
1659
1660/**
1661 * @function
1662 * @memberof Modifiers
1663 * @argument {Object} data - The data object generated by update method
1664 * @argument {Object} options - Modifiers configuration and options
1665 * @returns {Object} The data object, properly modified
1666 */
1667function keepTogether(data) {
1668  var _data$offsets = data.offsets,
1669      popper = _data$offsets.popper,
1670      reference = _data$offsets.reference;
1671
1672  var placement = data.placement.split('-')[0];
1673  var floor = Math.floor;
1674  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1675  var side = isVertical ? 'right' : 'bottom';
1676  var opSide = isVertical ? 'left' : 'top';
1677  var measurement = isVertical ? 'width' : 'height';
1678
1679  if (popper[side] < floor(reference[opSide])) {
1680    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
1681  }
1682  if (popper[opSide] > floor(reference[side])) {
1683    data.offsets.popper[opSide] = floor(reference[side]);
1684  }
1685
1686  return data;
1687}
1688
1689/**
1690 * Converts a string containing value + unit into a px value number
1691 * @function
1692 * @memberof {modifiers~offset}
1693 * @private
1694 * @argument {String} str - Value + unit string
1695 * @argument {String} measurement - `height` or `width`
1696 * @argument {Object} popperOffsets
1697 * @argument {Object} referenceOffsets
1698 * @returns {Number|String}
1699 * Value in pixels, or original string if no values were extracted
1700 */
1701function toValue(str, measurement, popperOffsets, referenceOffsets) {
1702  // separate value from unit
1703  var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
1704  var value = +split[1];
1705  var unit = split[2];
1706
1707  // If it's not a number it's an operator, I guess
1708  if (!value) {
1709    return str;
1710  }
1711
1712  if (unit.indexOf('%') === 0) {
1713    var element = void 0;
1714    switch (unit) {
1715      case '%p':
1716        element = popperOffsets;
1717        break;
1718      case '%':
1719      case '%r':
1720      default:
1721        element = referenceOffsets;
1722    }
1723
1724    var rect = getClientRect(element);
1725    return rect[measurement] / 100 * value;
1726  } else if (unit === 'vh' || unit === 'vw') {
1727    // if is a vh or vw, we calculate the size based on the viewport
1728    var size = void 0;
1729    if (unit === 'vh') {
1730      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
1731    } else {
1732      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
1733    }
1734    return size / 100 * value;
1735  } else {
1736    // if is an explicit pixel unit, we get rid of the unit and keep the value
1737    // if is an implicit unit, it's px, and we return just the value
1738    return value;
1739  }
1740}
1741
1742/**
1743 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
1744 * @function
1745 * @memberof {modifiers~offset}
1746 * @private
1747 * @argument {String} offset
1748 * @argument {Object} popperOffsets
1749 * @argument {Object} referenceOffsets
1750 * @argument {String} basePlacement
1751 * @returns {Array} a two cells array with x and y offsets in numbers
1752 */
1753function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
1754  var offsets = [0, 0];
1755
1756  // Use height if placement is left or right and index is 0 otherwise use width
1757  // in this way the first offset will use an axis and the second one
1758  // will use the other one
1759  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
1760
1761  // Split the offset string to obtain a list of values and operands
1762  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
1763  var fragments = offset.split(/(\+|\-)/).map(function (frag) {
1764    return frag.trim();
1765  });
1766
1767  // Detect if the offset string contains a pair of values or a single one
1768  // they could be separated by comma or space
1769  var divider = fragments.indexOf(find(fragments, function (frag) {
1770    return frag.search(/,|\s/) !== -1;
1771  }));
1772
1773  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
1774    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
1775  }
1776
1777  // If divider is found, we divide the list of values and operands to divide
1778  // them by ofset X and Y.
1779  var splitRegex = /\s*,\s*|\s+/;
1780  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];
1781
1782  // Convert the values with units to absolute pixels to allow our computations
1783  ops = ops.map(function (op, index) {
1784    // Most of the units rely on the orientation of the popper
1785    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
1786    var mergeWithPrevious = false;
1787    return op
1788    // This aggregates any `+` or `-` sign that aren't considered operators
1789    // e.g.: 10 + +5 => [10, +, +5]
1790    .reduce(function (a, b) {
1791      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
1792        a[a.length - 1] = b;
1793        mergeWithPrevious = true;
1794        return a;
1795      } else if (mergeWithPrevious) {
1796        a[a.length - 1] += b;
1797        mergeWithPrevious = false;
1798        return a;
1799      } else {
1800        return a.concat(b);
1801      }
1802    }, [])
1803    // Here we convert the string values into number values (in px)
1804    .map(function (str) {
1805      return toValue(str, measurement, popperOffsets, referenceOffsets);
1806    });
1807  });
1808
1809  // Loop trough the offsets arrays and execute the operations
1810  ops.forEach(function (op, index) {
1811    op.forEach(function (frag, index2) {
1812      if (isNumeric(frag)) {
1813        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
1814      }
1815    });
1816  });
1817  return offsets;
1818}
1819
1820/**
1821 * @function
1822 * @memberof Modifiers
1823 * @argument {Object} data - The data object generated by update method
1824 * @argument {Object} options - Modifiers configuration and options
1825 * @argument {Number|String} options.offset=0
1826 * The offset value as described in the modifier description
1827 * @returns {Object} The data object, properly modified
1828 */
1829function offset(data, _ref) {
1830  var offset = _ref.offset;
1831  var placement = data.placement,
1832      _data$offsets = data.offsets,
1833      popper = _data$offsets.popper,
1834      reference = _data$offsets.reference;
1835
1836  var basePlacement = placement.split('-')[0];
1837
1838  var offsets = void 0;
1839  if (isNumeric(+offset)) {
1840    offsets = [+offset, 0];
1841  } else {
1842    offsets = parseOffset(offset, popper, reference, basePlacement);
1843  }
1844
1845  if (basePlacement === 'left') {
1846    popper.top += offsets[0];
1847    popper.left -= offsets[1];
1848  } else if (basePlacement === 'right') {
1849    popper.top += offsets[0];
1850    popper.left += offsets[1];
1851  } else if (basePlacement === 'top') {
1852    popper.left += offsets[0];
1853    popper.top -= offsets[1];
1854  } else if (basePlacement === 'bottom') {
1855    popper.left += offsets[0];
1856    popper.top += offsets[1];
1857  }
1858
1859  data.popper = popper;
1860  return data;
1861}
1862
1863/**
1864 * @function
1865 * @memberof Modifiers
1866 * @argument {Object} data - The data object generated by `update` method
1867 * @argument {Object} options - Modifiers configuration and options
1868 * @returns {Object} The data object, properly modified
1869 */
1870function preventOverflow(data, options) {
1871  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
1872
1873  // If offsetParent is the reference element, we really want to
1874  // go one step up and use the next offsetParent as reference to
1875  // avoid to make this modifier completely useless and look like broken
1876  if (data.instance.reference === boundariesElement) {
1877    boundariesElement = getOffsetParent(boundariesElement);
1878  }
1879
1880  // NOTE: DOM access here
1881  // resets the popper's position so that the document size can be calculated excluding
1882  // the size of the popper element itself
1883  var transformProp = getSupportedPropertyName('transform');
1884  var popperStyles = data.instance.popper.style; // assignment to help minification
1885  var top = popperStyles.top,
1886      left = popperStyles.left,
1887      transform = popperStyles[transformProp];
1888
1889  popperStyles.top = '';
1890  popperStyles.left = '';
1891  popperStyles[transformProp] = '';
1892
1893  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
1894
1895  // NOTE: DOM access here
1896  // restores the original style properties after the offsets have been computed
1897  popperStyles.top = top;
1898  popperStyles.left = left;
1899  popperStyles[transformProp] = transform;
1900
1901  options.boundaries = boundaries;
1902
1903  var order = options.priority;
1904  var popper = data.offsets.popper;
1905
1906  var check = {
1907    primary: function primary(placement) {
1908      var value = popper[placement];
1909      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
1910        value = Math.max(popper[placement], boundaries[placement]);
1911      }
1912      return defineProperty({}, placement, value);
1913    },
1914    secondary: function secondary(placement) {
1915      var mainSide = placement === 'right' ? 'left' : 'top';
1916      var value = popper[mainSide];
1917      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
1918        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
1919      }
1920      return defineProperty({}, mainSide, value);
1921    }
1922  };
1923
1924  order.forEach(function (placement) {
1925    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
1926    popper = _extends({}, popper, check[side](placement));
1927  });
1928
1929  data.offsets.popper = popper;
1930
1931  return data;
1932}
1933
1934/**
1935 * @function
1936 * @memberof Modifiers
1937 * @argument {Object} data - The data object generated by `update` method
1938 * @argument {Object} options - Modifiers configuration and options
1939 * @returns {Object} The data object, properly modified
1940 */
1941function shift(data) {
1942  var placement = data.placement;
1943  var basePlacement = placement.split('-')[0];
1944  var shiftvariation = placement.split('-')[1];
1945
1946  // if shift shiftvariation is specified, run the modifier
1947  if (shiftvariation) {
1948    var _data$offsets = data.offsets,
1949        reference = _data$offsets.reference,
1950        popper = _data$offsets.popper;
1951
1952    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
1953    var side = isVertical ? 'left' : 'top';
1954    var measurement = isVertical ? 'width' : 'height';
1955
1956    var shiftOffsets = {
1957      start: defineProperty({}, side, reference[side]),
1958      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
1959    };
1960
1961    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
1962  }
1963
1964  return data;
1965}
1966
1967/**
1968 * @function
1969 * @memberof Modifiers
1970 * @argument {Object} data - The data object generated by update method
1971 * @argument {Object} options - Modifiers configuration and options
1972 * @returns {Object} The data object, properly modified
1973 */
1974function hide(data) {
1975  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
1976    return data;
1977  }
1978
1979  var refRect = data.offsets.reference;
1980  var bound = find(data.instance.modifiers, function (modifier) {
1981    return modifier.name === 'preventOverflow';
1982  }).boundaries;
1983
1984  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
1985    // Avoid unnecessary DOM access if visibility hasn't changed
1986    if (data.hide === true) {
1987      return data;
1988    }
1989
1990    data.hide = true;
1991    data.attributes['x-out-of-boundaries'] = '';
1992  } else {
1993    // Avoid unnecessary DOM access if visibility hasn't changed
1994    if (data.hide === false) {
1995      return data;
1996    }
1997
1998    data.hide = false;
1999    data.attributes['x-out-of-boundaries'] = false;
2000  }
2001
2002  return data;
2003}
2004
2005/**
2006 * @function
2007 * @memberof Modifiers
2008 * @argument {Object} data - The data object generated by `update` method
2009 * @argument {Object} options - Modifiers configuration and options
2010 * @returns {Object} The data object, properly modified
2011 */
2012function inner(data) {
2013  var placement = data.placement;
2014  var basePlacement = placement.split('-')[0];
2015  var _data$offsets = data.offsets,
2016      popper = _data$offsets.popper,
2017      reference = _data$offsets.reference;
2018
2019  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
2020
2021  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
2022
2023  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
2024
2025  data.placement = getOppositePlacement(placement);
2026  data.offsets.popper = getClientRect(popper);
2027
2028  return data;
2029}
2030
2031/**
2032 * Modifier function, each modifier can have a function of this type assigned
2033 * to its `fn` property.<br />
2034 * These functions will be called on each update, this means that you must
2035 * make sure they are performant enough to avoid performance bottlenecks.
2036 *
2037 * @function ModifierFn
2038 * @argument {dataObject} data - The data object generated by `update` method
2039 * @argument {Object} options - Modifiers configuration and options
2040 * @returns {dataObject} The data object, properly modified
2041 */
2042
2043/**
2044 * Modifiers are plugins used to alter the behavior of your poppers.<br />
2045 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
2046 * needed by the library.
2047 *
2048 * Usually you don't want to override the `order`, `fn` and `onLoad` props.
2049 * All the other properties are configurations that could be tweaked.
2050 * @namespace modifiers
2051 */
2052var modifiers = {
2053  /**
2054   * Modifier used to shift the popper on the start or end of its reference
2055   * element.<br />
2056   * It will read the variation of the `placement` property.<br />
2057   * It can be one either `-end` or `-start`.
2058   * @memberof modifiers
2059   * @inner
2060   */
2061  shift: {
2062    /** @prop {number} order=100 - Index used to define the order of execution */
2063    order: 100,
2064    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2065    enabled: true,
2066    /** @prop {ModifierFn} */
2067    fn: shift
2068  },
2069
2070  /**
2071   * The `offset` modifier can shift your popper on both its axis.
2072   *
2073   * It accepts the following units:
2074   * - `px` or unit-less, interpreted as pixels
2075   * - `%` or `%r`, percentage relative to the length of the reference element
2076   * - `%p`, percentage relative to the length of the popper element
2077   * - `vw`, CSS viewport width unit
2078   * - `vh`, CSS viewport height unit
2079   *
2080   * For length is intended the main axis relative to the placement of the popper.<br />
2081   * This means that if the placement is `top` or `bottom`, the length will be the
2082   * `width`. In case of `left` or `right`, it will be the `height`.
2083   *
2084   * You can provide a single value (as `Number` or `String`), or a pair of values
2085   * as `String` divided by a comma or one (or more) white space

2085s.<br />
2086   * The latter is a deprecated method because it leads to confusion and will be
2087   * removed in v2.<br />
2088   * Additionally, it accepts additions and subtractions between different units.
2089   * Note that multiplications and divisions aren't supported.
2090   *
2091   * Valid examples are:
2092   * ```
2093   * 10
2094   * '10%'
2095   * '10, 10'
2096   * '10%, 10'
2097   * '10 + 10%'
2098   * '10 - 5vh + 3%'
2099   * '-10px + 5vh, 5px - 6%'
2100   * ```
2101   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
2102   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
2103   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
2104   *
2105   * @memberof modifiers
2106   * @inner
2107   */
2108  offset: {
2109    /** @prop {number} order=200 - Index used to define the order of execution */
2110    order: 200,
2111    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2112    enabled: true,
2113    /** @prop {ModifierFn} */
2114    fn: offset,
2115    /** @prop {Number|String} offset=0
2116     * The offset value as described in the modifier description
2117     */
2118    offset: 0
2119  },
2120
2121  /**
2122   * Modifier used to prevent the popper from being positioned outside the boundary.
2123   *
2124   * A scenario exists where the reference itself is not within the boundaries.<br />
2125   * We can say it has "escaped the boundaries" — or just "escaped".<br />
2126   * In this case we need to decide whether the popper should either:
2127   *
2128   * - detach from the reference and remain "trapped" in the boundaries, or
2129   * - if it should ignore the boundary and "escape with its reference"
2130   *
2131   * When `escapeWithReference` is set to`true` and reference is completely
2132   * outside its boundaries, the popper will overflow (or completely leave)
2133   * the boundaries in order to remain attached to the edge of the reference.
2134   *
2135   * @memberof modifiers
2136   * @inner
2137   */
2138  preventOverflow: {
2139    /** @prop {number} order=300 - Index used to define the order of execution */
2140    order: 300,
2141    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2142    enabled: true,
2143    /** @prop {ModifierFn} */
2144    fn: preventOverflow,
2145    /**
2146     * @prop {Array} [priority=['left','right','top','bottom']]
2147     * Popper will try to prevent overflow following these priorities by default,
2148     * then, it could overflow on the left and on top of the `boundariesElement`
2149     */
2150    priority: ['left', 'right', 'top', 'bottom'],
2151    /**
2152     * @prop {number} padding=5
2153     * Amount of pixel used to define a minimum distance between the boundaries
2154     * and the popper. This makes sure the popper always has a little padding
2155     * between the edges of its container
2156     */
2157    padding: 5,
2158    /**
2159     * @prop {String|HTMLElement} boundariesElement='scrollParent'
2160     * Boundaries used by the modifier. Can be `scrollParent`, `window`,
2161     * `viewport` or any DOM element.
2162     */
2163    boundariesElement: 'scrollParent'
2164  },
2165
2166  /**
2167   * Modifier used to make sure the reference and its popper stay near each other
2168   * without leaving any gap between the two. Especially useful when the arrow is
2169   * enabled and you want to ensure that it points to its reference element.
2170   * It cares only about the first axis. You can still have poppers with margin
2171   * between the popper and its reference element.
2172   * @memberof modifiers
2173   * @inner
2174   */
2175  keepTogether: {
2176    /** @prop {number} order=400 - Index used to define the order of execution */
2177    order: 400,
2178    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2179    enabled: true,
2180    /** @prop {ModifierFn} */
2181    fn: keepTogether
2182  },
2183
2184  /**
2185   * This modifier is used to move the `arrowElement` of the popper to make
2186   * sure it is positioned between the reference element and its popper element.
2187   * It will read the outer size of the `arrowElement` node to detect how many
2188   * pixels of conjunction are needed.
2189   *
2190   * It has no effect if no `arrowElement` is provided.
2191   * @memberof modifiers
2192   * @inner
2193   */
2194  arrow: {
2195    /** @prop {number} order=500 - Index used to define the order of execution */
2196    order: 500,
2197    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2198    enabled: true,
2199    /** @prop {ModifierFn} */
2200    fn: arrow,
2201    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
2202    element: '[x-arrow]'
2203  },
2204
2205  /**
2206   * Modifier used to flip the popper's placement when it starts to overlap its
2207   * reference element.
2208   *
2209   * Requires the `preventOverflow` modifier before it in order to work.
2210   *
2211   * **NOTE:** this modifier will interrupt the current update cycle and will
2212   * restart it if it detects the need to flip the placement.
2213   * @memberof modifiers
2214   * @inner
2215   */
2216  flip: {
2217    /** @prop {number} order=600 - Index used to define the order of execution */
2218    order: 600,
2219    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2220    enabled: true,
2221    /** @prop {ModifierFn} */
2222    fn: flip,
2223    /**
2224     * @prop {String|Array} behavior='flip'
2225     * The behavior used to change the popper's placement. It can be one of
2226     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
2227     * placements (with optional variations)
2228     */
2229    behavior: 'flip',
2230    /**
2231     * @prop {number} padding=5
2232     * The popper will flip if it hits the edges of the `boundariesElement`
2233     */
2234    padding: 5,
2235    /**
2236     * @prop {String|HTMLElement} boundariesElement='viewport'
2237     * The element which will define the boundaries of the popper position.
2238     * The popper will never be placed outside of the defined boundaries
2239     * (except if `keepTogether` is enabled)
2240     */
2241    boundariesElement: 'viewport',
2242    /**
2243     * @prop {Boolean} flipVariations=false
2244     * The popper will switch placement variation between `-start` and `-end` when
2245     * the reference element overlaps its boundaries.
2246     *
2247     * The original placement should have a set variation.
2248     */
2249    flipVariations: false,
2250    /**
2251     * @prop {Boolean} flipVariationsByContent=false
2252     * The popper will switch placement variation between `-start` and `-end` when
2253     * the popper element overlaps its reference boundaries.
2254     *
2255     * The original placement should have a set variation.
2256     */
2257    flipVariationsByContent: false
2258  },
2259
2260  /**
2261   * Modifier used to make the popper flow toward the inner of the reference element.
2262   * By default, when this modifier is disabled, the popper will be placed outside
2263   * the reference element.
2264   * @memberof modifiers
2265   * @inner
2266   */
2267  inner: {
2268    /** @prop {number} order=700 - Index used to define the order of execution */
2269    order: 700,
2270    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
2271    enabled: false,
2272    /** @prop {ModifierFn} */
2273    fn: inner
2274  },
2275
2276  /**
2277   * Modifier used to hide the popper when its reference element is outside of the
2278   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
2279   * be used to hide with a CSS selector the popper when its reference is
2280   * out of boundaries.
2281   *
2282   * Requires the `preventOverflow` modifier before it in order to work.
2283   * @memberof modifiers
2284   * @inner
2285   */
2286  hide: {
2287    /** @prop {number} order=800 - Index used to define the order of execution */
2288    order: 800,
2289    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2290    enabled: true,
2291    /** @prop {ModifierFn} */
2292    fn: hide
2293  },
2294
2295  /**
2296   * Computes the style that will be applied to the popper element to gets
2297   * properly positioned.
2298   *
2299   * Note that this modifier will not touch the DOM, it just prepares the styles
2300   * so that `applyStyle` modifier can apply it. This separation is useful
2301   * in case you need to replace `applyStyle` with a custom implementation.
2302   *
2303   * This modifier has `850` as `order` value to maintain backward compatibility
2304   * with previous versions of Popper.js. Expect the modifiers ordering method
2305   * to change in future major versions of the library.
2306   *
2307   * @memberof modifiers
2308   * @inner
2309   */
2310  computeStyle: {
2311    /** @prop {number} order=850 - Index used to define the order of execution */
2312    order: 850,
2313    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2314    enabled: true,
2315    /** @prop {ModifierFn} */
2316    fn: computeStyle,
2317    /**
2318     * @prop {Boolean} gpuAcceleration=true
2319     * If true, it uses the CSS 3D transformation to position the popper.
2320     * Otherwise, it will use the `top` and `left` properties
2321     */
2322    gpuAcceleration: true,
2323    /**
2324     * @prop {string} [x='bottom']
2325     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
2326     * Change this if your popper should grow in a direction different from `bottom`
2327     */
2328    x: 'bottom',
2329    /**
2330     * @prop {string} [x='left']
2331     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
2332     * Change this if your popper should grow in a direction different from `right`
2333     */
2334    y: 'right'
2335  },
2336
2337  /**
2338   * Applies the computed styles to the popper element.
2339   *
2340   * All the DOM manipulations are limited to this modifier. This is useful in case
2341   * you want to integrate Popper.js inside a framework or view library and you
2342   * want to delegate all the DOM manipulations to it.
2343   *
2344   * Note that if you disable this modifier, you must make sure the popper element
2345   * has its position set to `absolute` before Popper.js can do its work!
2346   *
2347   * Just disable this modifier and define your own to achieve the desired effect.
2348   *
2349   * @memberof modifiers
2350   * @inner
2351   */
2352  applyStyle: {
2353    /** @prop {number} order=900 - Index used to define the order of execution */
2354    order: 900,
2355    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2356    enabled: true,
2357    /** @prop {ModifierFn} */

2358    fn: applyStyle,
2359    /** @prop {Function} */
2360    onLoad: applyStyleOnLoad,
2361    /**
2362     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
2363     * @prop {Boolean} gpuAcceleration=true
2364     * If true, it uses the CSS 3D transformation to position the popper.
2365     * Otherwise, it will use the `top` and `left` properties
2366     */
2367    gpuAcceleration: undefined
2368  }
2369};
2370
2371/**
2372 * The `dataObject` is an object containing all the information used by Popper.js.
2373 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
2374 * @name dataObject
2375 * @property {Object} data.instance The Popper.js instance
2376 * @property {String} data.placement Placement applied to popper
2377 * @property {String} data.originalPlacement Placement originally defined on init
2378 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
2379 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
2380 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
2381 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
2382 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
2383 * @property {Object} data.boundaries Offsets of the popper boundaries
2384 * @property {Object} data.offsets The measurements of popper, reference and arrow elements
2385 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
2386 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
2387 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
2388 */
2389
2390/**
2391 * Default options provided to Popper.js constructor.<br />
2392 * These can be overridden using the `options` argument of Popper.js.<br />
2393 * To override an option, simply pass an object with the same
2394 * structure of the `options` object, as the 3rd argument. For example:
2395 * ```
2396 * new Popper(ref, pop, {
2397 *   modifiers: {
2398 *     preventOverflow: { enabled: false }
2399 *   }
2400 * })
2401 * ```
2402 * @type {Object}
2403 * @static
2404 * @memberof Popper
2405 */
2406var Defaults = {
2407  /**
2408   * Popper's placement.
2409   * @prop {Popper.placements} placement='bottom'
2410   */
2411  placement: 'bottom',
2412
2413  /**
2414   * Set this to true if you want popper to position it self in 'fixed' mode
2415   * @prop {Boolean} positionFixed=false
2416   */
2417  positionFixed: false,
2418
2419  /**
2420   * Whether events (resize, scroll) are initially enabled.
2421   * @prop {Boolean} eventsEnabled=true
2422   */
2423  eventsEnabled: true,
2424
2425  /**
2426   * Set to true if you want to automatically remove the popper when
2427   * you call the `destroy` method.
2428   * @prop {Boolean} removeOnDestroy=false
2429   */
2430  removeOnDestroy: false,
2431
2432  /**
2433   * Callback called when the popper is created.<br />
2434   * By default, it is set to no-op.<br />
2435   * Access Popper.js instance with `data.instance`.
2436   * @prop {onCreate}
2437   */
2438  onCreate: function onCreate() {},
2439
2440  /**
2441   * Callback called when the popper is updated. This callback is not called
2442   * on the initialization/creation of the popper, but only on subsequent
2443   * updates.<br />
2444   * By default, it is set to no-op.<br />
2445   * Access Popper.js instance with `data.instance`.
2446   * @prop {onUpdate}
2447   */
2448  onUpdate: function onUpdate() {},
2449
2450  /**
2451   * List of modifiers used to modify the offsets before they are applied to the popper.
2452   * They provide most of the functionalities of Popper.js.
2453   * @prop {modifiers}
2454   */
2455  modifiers: modifiers
2456};
2457
2458/**
2459 * @callback onCreate
2460 * @param {dataObject} data
2461 */
2462
2463/**
2464 * @callback onUpdate
2465 * @param {dataObject} data
2466 */
2467
2468// Utils
2469// Methods
2470var Popper = function () {
2471  /**
2472   * Creates a new Popper.js instance.
2473   * @class Popper
2474   * @param {Element|referenceObject} reference - The reference element used to position the popper
2475   * @param {Element} popper - The HTML / XML element used as the popper
2476   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
2477   * @return {Object} instance - The generated Popper.js instance
2478   */
2479  function Popper(reference, popper) {
2480    var _this = this;
2481
2482    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
2483    classCallCheck(this, Popper);
2484
2485    this.scheduleUpdate = function () {
2486      return requestAnimationFrame(_this.update);
2487    };
2488
2489    // make update() debounced, so that it only runs at most once-per-tick
2490    this.update = debounce(this.update.bind(this));
2491
2492    // with {} we create a new object with the options inside it
2493    this.options = _extends({}, Popper.Defaults, options);
2494
2495    // init state
2496    this.state = {
2497      isDestroyed: false,
2498      isCreated: false,
2499      scrollParents: []
2500    };
2501
2502    // get reference and popper elements (allow jQuery wrappers)
2503    this.reference = reference && reference.jquery ? reference[0] : reference;
2504    this.popper = popper && popper.jquery ? popper[0] : popper;
2505
2506    // Deep merge modifiers options
2507    this.options.modifiers = {};
2508    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
2509      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
2510    });
2511
2512    // Refactoring modifiers' list (Object => Array)
2513    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
2514      return _extends({
2515        name: name
2516      }, _this.options.modifiers[name]);
2517    })
2518    // sort the modifiers by order
2519    .sort(function (a, b) {
2520      return a.order - b.order;
2521    });
2522
2523    // modifiers have the ability to execute arbitrary code when Popper.js get inited
2524    // such code is executed in the same order of its modifier
2525    // they could add new properties to their options configuration
2526    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
2527    this.modifiers.forEach(function (modifierOptions) {
2528      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
2529        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
2530      }
2531    });
2532
2533    // fire the first update to position the popper in the right place
2534    this.update();
2535
2536    var eventsEnabled = this.options.eventsEnabled;
2537    if (eventsEnabled) {
2538      // setup event listeners, they will take care of update the position in specific situations
2539      this.enableEventListeners();
2540    }
2541
2542    this.state.eventsEnabled = eventsEnabled;
2543  }
2544
2545  // We can't use class properties because they don't get listed in the
2546  // class prototype and break stuff like Sinon stubs
2547
2548
2549  createClass(Popper, [{
2550    key: 'update',
2551    value: function update$$1() {
2552      return update.call(this);
2553    }
2554  }, {
2555    key: 'destroy',
2556    value: function destroy$$1() {
2557      return destroy.call(this);
2558    }
2559  }, {
2560    key: 'enableEventListeners',
2561    value: function enableEventListeners$$1() {
2562      return enableEventListeners.call(this);
2563    }
2564  }, {
2565    key: 'disableEventListeners',
2566    value: function disableEventListeners$$1() {
2567      return disableEventListeners.call(this);
2568    }
2569
2570    /**
2571     * Schedules an update. It will run on the next UI update available.
2572     * @method scheduleUpdate
2573     * @memberof Popper
2574     */
2575
2576
2577    /**
2578     * Collection of utilities useful when writing custom modifiers.
2579     * Starting from version 1.7, this method is available only if you
2580     * include `popper-utils.js` before `popper.js`.
2581     *
2582     * **DEPRECATION**: This way to access PopperUtils is deprecated
2583     * and will be removed in v2! Use the PopperUtils module directly instead.
2584     * Due to the high instability of the methods contained in Utils, we can't
2585     * guarantee them to follow semver. Use them at your own risk!
2586     * @static
2587     * @private
2588     * @type {Object}
2589     * @deprecated since version 1.8
2590     * @member Utils
2591     * @memberof Popper
2592     */
2593
2594  }]);
2595  return Popper;
2596}();
2597
2598/**
2599 * The `referenceObject` is an object that provides an interface compatible with Popper.js
2600 * and lets you use it as replacement of a real DOM node.<br />
2601 * You can use this method to position a popper relatively to a set of coordinates
2602 * in case you don't have a DOM node to use as reference.
2603 *
2604 * ```
2605 * new Popper(referenceObject, popperNode);
2606 * ```
2607 *
2608 * NB: This feature isn't supported in Internet Explorer 10.
2609 * @name referenceObject
2610 * @property {Function} data.getBoundingClientRect
2611 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
2612 * @property {number} data.clientWidth
2613 * An ES6 getter that will return the width of the virtual reference element.
2614 * @property {number} data.clientHeight
2615 * An ES6 getter that will return the height of the virtual reference element.
2616 */
2617
2618
2619Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
2620Popper.placements = placements;
2621Popper.Defaults = Defaults;
2622

2623return Popper;
2624
2625})));
2626//# sourceMappingURL=popper.js.map
2627
2628/*!
2629  * Bootstrap v4.5.0 (https://getbootstrap.com/)
2630  * Copyright 2011-2020 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
2631  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2632  */
2633(function (global, factory) {
2634  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) :
2635  typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) :
2636  (global = global || self, factory(global.bootstrap = {}, global.jQuery, global.Popper));
2637}(this, (function (exports, $, Popper) { 'use strict';
2638
2639  $ = $ && Object.prototype.hasOwnProperty.call($, 'default') ? $['default'] : $;
2640  Popper = Popper && Object.prototype.hasOwnProperty.call(Popper, 'default') ? Popper['default'] : Popper;
2641
2642  function _defineProperties(target, props) {
2643    for (var i = 0; i < props.length; i++) {
2644      var descriptor = props[i];
2645      descriptor.enumerable = descriptor.enumerable || false;
2646      descriptor.configurable = true;
2647      if ("value" in descriptor) descriptor.writable = true;
2648      Object.defineProperty(target, descriptor.key, descriptor);
2649    }
2650  }
2651
2652  function _createClass(Constructor, protoProps, staticProps) {
2653    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
2654    if (staticProps) _defineProperties(Constructor, staticProps);
2655    return Constructor;
2656  }
2657
2658  function _defineProperty(obj, key, value) {
2659    if (key in obj) {
2660      Object.defineProperty(obj, key, {
2661        value: value,
2662        enumerable: true,
2663        configurable: true,
2664        writable: true
2665      });
2666    } else {
2667      obj[key] = value;
2668    }
2669
2670    return obj;
2671  }
2672
2673  function ownKeys(object, enumerableOnly) {
2674    var keys = Object.keys(object);
2675
2676    if (Object.getOwnPropertySymbols) {
2677      var symbols = Object.getOwnPropertySymbols(object);
2678      if (enumerableOnly) symbols = symbols.filter(function (sym) {
2679        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
2680      });
2681      keys.push.apply(keys, symbols);
2682    }
2683
2684    return keys;
2685  }
2686