Subversion Repositories oidplus

Rev

Go to most recent revision | View as "text/javascript" | Blame | Last modification | View Log | RSS feed

  1. /*!
  2.   * Bootstrap v4.0.0 (https://getbootstrap.com)
  3.   * Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
  4.   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  5.   */
  6. (function (global, factory) {
  7.         typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) :
  8.         typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :
  9.         (factory((global.bootstrap = {}),global.jQuery));
  10. }(this, (function (exports,$) { 'use strict';
  11.  
  12. $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
  13.  
  14. function _defineProperties(target, props) {
  15.   for (var i = 0; i < props.length; i++) {
  16.     var descriptor = props[i];
  17.     descriptor.enumerable = descriptor.enumerable || false;
  18.     descriptor.configurable = true;
  19.     if ("value" in descriptor) descriptor.writable = true;
  20.     Object.defineProperty(target, descriptor.key, descriptor);
  21.   }
  22. }
  23.  
  24. function _createClass(Constructor, protoProps, staticProps) {
  25.   if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  26.   if (staticProps) _defineProperties(Constructor, staticProps);
  27.   return Constructor;
  28. }
  29.  
  30. function _extends() {
  31.   _extends = Object.assign || function (target) {
  32.     for (var i = 1; i < arguments.length; i++) {
  33.       var source = arguments[i];
  34.  
  35.       for (var key in source) {
  36.         if (Object.prototype.hasOwnProperty.call(source, key)) {
  37.           target[key] = source[key];
  38.         }
  39.       }
  40.     }
  41.  
  42.     return target;
  43.   };
  44.  
  45.   return _extends.apply(this, arguments);
  46. }
  47.  
  48. function _inheritsLoose(subClass, superClass) {
  49.   subClass.prototype = Object.create(superClass.prototype);
  50.   subClass.prototype.constructor = subClass;
  51.   subClass.__proto__ = superClass;
  52. }
  53.  
  54. /**
  55.  * --------------------------------------------------------------------------
  56.  * Bootstrap (v4.0.0): util.js
  57.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  58.  * --------------------------------------------------------------------------
  59.  */
  60.  
  61. var Util = function ($$$1) {
  62.   /**
  63.    * ------------------------------------------------------------------------
  64.    * Private TransitionEnd Helpers
  65.    * ------------------------------------------------------------------------
  66.    */
  67.   var transition = false;
  68.   var MAX_UID = 1000000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
  69.  
  70.   function toType(obj) {
  71.     return {}.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
  72.   }
  73.  
  74.   function getSpecialTransitionEndEvent() {
  75.     return {
  76.       bindType: transition.end,
  77.       delegateType: transition.end,
  78.       handle: function handle(event) {
  79.         if ($$$1(event.target).is(this)) {
  80.           return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
  81.         }
  82.  
  83.         return undefined; // eslint-disable-line no-undefined
  84.       }
  85.     };
  86.   }
  87.  
  88.   function transitionEndTest() {
  89.     if (typeof window !== 'undefined' && window.QUnit) {
  90.       return false;
  91.     }
  92.  
  93.     return {
  94.       end: 'transitionend'
  95.     };
  96.   }
  97.  
  98.   function transitionEndEmulator(duration) {
  99.     var _this = this;
  100.  
  101.     var called = false;
  102.     $$$1(this).one(Util.TRANSITION_END, function () {
  103.       called = true;
  104.     });
  105.     setTimeout(function () {
  106.       if (!called) {
  107.         Util.triggerTransitionEnd(_this);
  108.       }
  109.     }, duration);
  110.     return this;
  111.   }
  112.  
  113.   function setTransitionEndSupport() {
  114.     transition = transitionEndTest();
  115.     $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
  116.  
  117.     if (Util.supportsTransitionEnd()) {
  118.       $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
  119.     }
  120.   }
  121.  
  122.   function escapeId(selector) {
  123.     // We escape IDs in case of special selectors (selector = '#myId:something')
  124.     // $.escapeSelector does not exist in jQuery < 3
  125.     selector = typeof $$$1.escapeSelector === 'function' ? $$$1.escapeSelector(selector).substr(1) : selector.replace(/(:|\.|\[|\]|,|=|@)/g, '\\$1');
  126.     return selector;
  127.   }
  128.   /**
  129.    * --------------------------------------------------------------------------
  130.    * Public Util Api
  131.    * --------------------------------------------------------------------------
  132.    */
  133.  
  134.  
  135.   var Util = {
  136.     TRANSITION_END: 'bsTransitionEnd',
  137.     getUID: function getUID(prefix) {
  138.       do {
  139.         // eslint-disable-next-line no-bitwise
  140.         prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
  141.       } while (document.getElementById(prefix));
  142.  
  143.       return prefix;
  144.     },
  145.     getSelectorFromElement: function getSelectorFromElement(element) {
  146.       var selector = element.getAttribute('data-target');
  147.  
  148.       if (!selector || selector === '#') {
  149.         selector = element.getAttribute('href') || '';
  150.       } // If it's an ID
  151.  
  152.  
  153.       if (selector.charAt(0) === '#') {
  154.         selector = escapeId(selector);
  155.       }
  156.  
  157.       try {
  158.         var $selector = $$$1(document).find(selector);
  159.         return $selector.length > 0 ? selector : null;
  160.       } catch (err) {
  161.         return null;
  162.       }
  163.     },
  164.     reflow: function reflow(element) {
  165.       return element.offsetHeight;
  166.     },
  167.     triggerTransitionEnd: function triggerTransitionEnd(element) {
  168.       $$$1(element).trigger(transition.end);
  169.     },
  170.     supportsTransitionEnd: function supportsTransitionEnd() {
  171.       return Boolean(transition);
  172.     },
  173.     isElement: function isElement(obj) {
  174.       return (obj[0] || obj).nodeType;
  175.     },
  176.     typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
  177.       for (var property in configTypes) {
  178.         if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
  179.           var expectedTypes = configTypes[property];
  180.           var value = config[property];
  181.           var valueType = value && Util.isElement(value) ? 'element' : toType(value);
  182.  
  183.           if (!new RegExp(expectedTypes).test(valueType)) {
  184.             throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
  185.           }
  186.         }
  187.       }
  188.     }
  189.   };
  190.   setTransitionEndSupport();
  191.   return Util;
  192. }($);
  193.  
  194. /**
  195.  * --------------------------------------------------------------------------
  196.  * Bootstrap (v4.0.0): alert.js
  197.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  198.  * --------------------------------------------------------------------------
  199.  */
  200.  
  201. var Alert = function ($$$1) {
  202.   /**
  203.    * ------------------------------------------------------------------------
  204.    * Constants
  205.    * ------------------------------------------------------------------------
  206.    */
  207.   var NAME = 'alert';
  208.   var VERSION = '4.0.0';
  209.   var DATA_KEY = 'bs.alert';
  210.   var EVENT_KEY = "." + DATA_KEY;
  211.   var DATA_API_KEY = '.data-api';
  212.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  213.   var TRANSITION_DURATION = 150;
  214.   var Selector = {
  215.     DISMISS: '[data-dismiss="alert"]'
  216.   };
  217.   var Event = {
  218.     CLOSE: "close" + EVENT_KEY,
  219.     CLOSED: "closed" + EVENT_KEY,
  220.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
  221.   };
  222.   var ClassName = {
  223.     ALERT: 'alert',
  224.     FADE: 'fade',
  225.     SHOW: 'show'
  226.     /**
  227.      * ------------------------------------------------------------------------
  228.      * Class Definition
  229.      * ------------------------------------------------------------------------
  230.      */
  231.  
  232.   };
  233.  
  234.   var Alert =
  235.   /*#__PURE__*/
  236.   function () {
  237.     function Alert(element) {
  238.       this._element = element;
  239.     } // Getters
  240.  
  241.  
  242.     var _proto = Alert.prototype;
  243.  
  244.     // Public
  245.     _proto.close = function close(element) {
  246.       element = element || this._element;
  247.  
  248.       var rootElement = this._getRootElement(element);
  249.  
  250.       var customEvent = this._triggerCloseEvent(rootElement);
  251.  
  252.       if (customEvent.isDefaultPrevented()) {
  253.         return;
  254.       }
  255.  
  256.       this._removeElement(rootElement);
  257.     };
  258.  
  259.     _proto.dispose = function dispose() {
  260.       $$$1.removeData(this._element, DATA_KEY);
  261.       this._element = null;
  262.     }; // Private
  263.  
  264.  
  265.     _proto._getRootElement = function _getRootElement(element) {
  266.       var selector = Util.getSelectorFromElement(element);
  267.       var parent = false;
  268.  
  269.       if (selector) {
  270.         parent = $$$1(selector)[0];
  271.       }
  272.  
  273.       if (!parent) {
  274.         parent = $$$1(element).closest("." + ClassName.ALERT)[0];
  275.       }
  276.  
  277.       return parent;
  278.     };
  279.  
  280.     _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
  281.       var closeEvent = $$$1.Event(Event.CLOSE);
  282.       $$$1(element).trigger(closeEvent);
  283.       return closeEvent;
  284.     };
  285.  
  286.     _proto._removeElement = function _removeElement(element) {
  287.       var _this = this;
  288.  
  289.       $$$1(element).removeClass(ClassName.SHOW);
  290.  
  291.       if (!Util.supportsTransitionEnd() || !$$$1(element).hasClass(ClassName.FADE)) {
  292.         this._destroyElement(element);
  293.  
  294.         return;
  295.       }
  296.  
  297.       $$$1(element).one(Util.TRANSITION_END, function (event) {
  298.         return _this._destroyElement(element, event);
  299.       }).emulateTransitionEnd(TRANSITION_DURATION);
  300.     };
  301.  
  302.     _proto._destroyElement = function _destroyElement(element) {
  303.       $$$1(element).detach().trigger(Event.CLOSED).remove();
  304.     }; // Static
  305.  
  306.  
  307.     Alert._jQueryInterface = function _jQueryInterface(config) {
  308.       return this.each(function () {
  309.         var $element = $$$1(this);
  310.         var data = $element.data(DATA_KEY);
  311.  
  312.         if (!data) {
  313.           data = new Alert(this);
  314.           $element.data(DATA_KEY, data);
  315.         }
  316.  
  317.         if (config === 'close') {
  318.           data[config](this);
  319.         }
  320.       });
  321.     };
  322.  
  323.     Alert._handleDismiss = function _handleDismiss(alertInstance) {
  324.       return function (event) {
  325.         if (event) {
  326.           event.preventDefault();
  327.         }
  328.  
  329.         alertInstance.close(this);
  330.       };
  331.     };
  332.  
  333.     _createClass(Alert, null, [{
  334.       key: "VERSION",
  335.       get: function get() {
  336.         return VERSION;
  337.       }
  338.     }]);
  339.     return Alert;
  340.   }();
  341.   /**
  342.    * ------------------------------------------------------------------------
  343.    * Data Api implementation
  344.    * ------------------------------------------------------------------------
  345.    */
  346.  
  347.  
  348.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
  349.   /**
  350.    * ------------------------------------------------------------------------
  351.    * jQuery
  352.    * ------------------------------------------------------------------------
  353.    */
  354.  
  355.   $$$1.fn[NAME] = Alert._jQueryInterface;
  356.   $$$1.fn[NAME].Constructor = Alert;
  357.  
  358.   $$$1.fn[NAME].noConflict = function () {
  359.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  360.     return Alert._jQueryInterface;
  361.   };
  362.  
  363.   return Alert;
  364. }($);
  365.  
  366. /**
  367.  * --------------------------------------------------------------------------
  368.  * Bootstrap (v4.0.0): button.js
  369.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  370.  * --------------------------------------------------------------------------
  371.  */
  372.  
  373. var Button = function ($$$1) {
  374.   /**
  375.    * ------------------------------------------------------------------------
  376.    * Constants
  377.    * ------------------------------------------------------------------------
  378.    */
  379.   var NAME = 'button';
  380.   var VERSION = '4.0.0';
  381.   var DATA_KEY = 'bs.button';
  382.   var EVENT_KEY = "." + DATA_KEY;
  383.   var DATA_API_KEY = '.data-api';
  384.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  385.   var ClassName = {
  386.     ACTIVE: 'active',
  387.     BUTTON: 'btn',
  388.     FOCUS: 'focus'
  389.   };
  390.   var Selector = {
  391.     DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
  392.     DATA_TOGGLE: '[data-toggle="buttons"]',
  393.     INPUT: 'input',
  394.     ACTIVE: '.active',
  395.     BUTTON: '.btn'
  396.   };
  397.   var Event = {
  398.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
  399.     FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
  400.     /**
  401.      * ------------------------------------------------------------------------
  402.      * Class Definition
  403.      * ------------------------------------------------------------------------
  404.      */
  405.  
  406.   };
  407.  
  408.   var Button =
  409.   /*#__PURE__*/
  410.   function () {
  411.     function Button(element) {
  412.       this._element = element;
  413.     } // Getters
  414.  
  415.  
  416.     var _proto = Button.prototype;
  417.  
  418.     // Public
  419.     _proto.toggle = function toggle() {
  420.       var triggerChangeEvent = true;
  421.       var addAriaPressed = true;
  422.       var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
  423.  
  424.       if (rootElement) {
  425.         var input = $$$1(this._element).find(Selector.INPUT)[0];
  426.  
  427.         if (input) {
  428.           if (input.type === 'radio') {
  429.             if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
  430.               triggerChangeEvent = false;
  431.             } else {
  432.               var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
  433.  
  434.               if (activeElement) {
  435.                 $$$1(activeElement).removeClass(ClassName.ACTIVE);
  436.               }
  437.             }
  438.           }
  439.  
  440.           if (triggerChangeEvent) {
  441.             if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
  442.               return;
  443.             }
  444.  
  445.             input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
  446.             $$$1(input).trigger('change');
  447.           }
  448.  
  449.           input.focus();
  450.           addAriaPressed = false;
  451.         }
  452.       }
  453.  
  454.       if (addAriaPressed) {
  455.         this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
  456.       }
  457.  
  458.       if (triggerChangeEvent) {
  459.         $$$1(this._element).toggleClass(ClassName.ACTIVE);
  460.       }
  461.     };
  462.  
  463.     _proto.dispose = function dispose() {
  464.       $$$1.removeData(this._element, DATA_KEY);
  465.       this._element = null;
  466.     }; // Static
  467.  
  468.  
  469.     Button._jQueryInterface = function _jQueryInterface(config) {
  470.       return this.each(function () {
  471.         var data = $$$1(this).data(DATA_KEY);
  472.  
  473.         if (!data) {
  474.           data = new Button(this);
  475.           $$$1(this).data(DATA_KEY, data);
  476.         }
  477.  
  478.         if (config === 'toggle') {
  479.           data[config]();
  480.         }
  481.       });
  482.     };
  483.  
  484.     _createClass(Button, null, [{
  485.       key: "VERSION",
  486.       get: function get() {
  487.         return VERSION;
  488.       }
  489.     }]);
  490.     return Button;
  491.   }();
  492.   /**
  493.    * ------------------------------------------------------------------------
  494.    * Data Api implementation
  495.    * ------------------------------------------------------------------------
  496.    */
  497.  
  498.  
  499.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
  500.     event.preventDefault();
  501.     var button = event.target;
  502.  
  503.     if (!$$$1(button).hasClass(ClassName.BUTTON)) {
  504.       button = $$$1(button).closest(Selector.BUTTON);
  505.     }
  506.  
  507.     Button._jQueryInterface.call($$$1(button), 'toggle');
  508.   }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
  509.     var button = $$$1(event.target).closest(Selector.BUTTON)[0];
  510.     $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
  511.   });
  512.   /**
  513.    * ------------------------------------------------------------------------
  514.    * jQuery
  515.    * ------------------------------------------------------------------------
  516.    */
  517.  
  518.   $$$1.fn[NAME] = Button._jQueryInterface;
  519.   $$$1.fn[NAME].Constructor = Button;
  520.  
  521.   $$$1.fn[NAME].noConflict = function () {
  522.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  523.     return Button._jQueryInterface;
  524.   };
  525.  
  526.   return Button;
  527. }($);
  528.  
  529. /**
  530.  * --------------------------------------------------------------------------
  531.  * Bootstrap (v4.0.0): carousel.js
  532.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  533.  * --------------------------------------------------------------------------
  534.  */
  535.  
  536. var Carousel = function ($$$1) {
  537.   /**
  538.    * ------------------------------------------------------------------------
  539.    * Constants
  540.    * ------------------------------------------------------------------------
  541.    */
  542.   var NAME = 'carousel';
  543.   var VERSION = '4.0.0';
  544.   var DATA_KEY = 'bs.carousel';
  545.   var EVENT_KEY = "." + DATA_KEY;
  546.   var DATA_API_KEY = '.data-api';
  547.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  548.   var TRANSITION_DURATION = 600;
  549.   var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
  550.  
  551.   var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
  552.  
  553.   var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
  554.  
  555.   var Default = {
  556.     interval: 5000,
  557.     keyboard: true,
  558.     slide: false,
  559.     pause: 'hover',
  560.     wrap: true
  561.   };
  562.   var DefaultType = {
  563.     interval: '(number|boolean)',
  564.     keyboard: 'boolean',
  565.     slide: '(boolean|string)',
  566.     pause: '(string|boolean)',
  567.     wrap: 'boolean'
  568.   };
  569.   var Direction = {
  570.     NEXT: 'next',
  571.     PREV: 'prev',
  572.     LEFT: 'left',
  573.     RIGHT: 'right'
  574.   };
  575.   var Event = {
  576.     SLIDE: "slide" + EVENT_KEY,
  577.     SLID: "slid" + EVENT_KEY,
  578.     KEYDOWN: "keydown" + EVENT_KEY,
  579.     MOUSEENTER: "mouseenter" + EVENT_KEY,
  580.     MOUSELEAVE: "mouseleave" + EVENT_KEY,
  581.     TOUCHEND: "touchend" + EVENT_KEY,
  582.     LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
  583.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
  584.   };
  585.   var ClassName = {
  586.     CAROUSEL: 'carousel',
  587.     ACTIVE: 'active',
  588.     SLIDE: 'slide',
  589.     RIGHT: 'carousel-item-right',
  590.     LEFT: 'carousel-item-left',
  591.     NEXT: 'carousel-item-next',
  592.     PREV: 'carousel-item-prev',
  593.     ITEM: 'carousel-item'
  594.   };
  595.   var Selector = {
  596.     ACTIVE: '.active',
  597.     ACTIVE_ITEM: '.active.carousel-item',
  598.     ITEM: '.carousel-item',
  599.     NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
  600.     INDICATORS: '.carousel-indicators',
  601.     DATA_SLIDE: '[data-slide], [data-slide-to]',
  602.     DATA_RIDE: '[data-ride="carousel"]'
  603.     /**
  604.      * ------------------------------------------------------------------------
  605.      * Class Definition
  606.      * ------------------------------------------------------------------------
  607.      */
  608.  
  609.   };
  610.  
  611.   var Carousel =
  612.   /*#__PURE__*/
  613.   function () {
  614.     function Carousel(element, config) {
  615.       this._items = null;
  616.       this._interval = null;
  617.       this._activeElement = null;
  618.       this._isPaused = false;
  619.       this._isSliding = false;
  620.       this.touchTimeout = null;
  621.       this._config = this._getConfig(config);
  622.       this._element = $$$1(element)[0];
  623.       this._indicatorsElement = $$$1(this._element).find(Selector.INDICATORS)[0];
  624.  
  625.       this._addEventListeners();
  626.     } // Getters
  627.  
  628.  
  629.     var _proto = Carousel.prototype;
  630.  
  631.     // Public
  632.     _proto.next = function next() {
  633.       if (!this._isSliding) {
  634.         this._slide(Direction.NEXT);
  635.       }
  636.     };
  637.  
  638.     _proto.nextWhenVisible = function nextWhenVisible() {
  639.       // Don't call next when the page isn't visible
  640.       // or the carousel or its parent isn't visible
  641.       if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
  642.         this.next();
  643.       }
  644.     };
  645.  
  646.     _proto.prev = function prev() {
  647.       if (!this._isSliding) {
  648.         this._slide(Direction.PREV);
  649.       }
  650.     };
  651.  
  652.     _proto.pause = function pause(event) {
  653.       if (!event) {
  654.         this._isPaused = true;
  655.       }
  656.  
  657.       if ($$$1(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) {
  658.         Util.triggerTransitionEnd(this._element);
  659.         this.cycle(true);
  660.       }
  661.  
  662.       clearInterval(this._interval);
  663.       this._interval = null;
  664.     };
  665.  
  666.     _proto.cycle = function cycle(event) {
  667.       if (!event) {
  668.         this._isPaused = false;
  669.       }
  670.  
  671.       if (this._interval) {
  672.         clearInterval(this._interval);
  673.         this._interval = null;
  674.       }
  675.  
  676.       if (this._config.interval && !this._isPaused) {
  677.         this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
  678.       }
  679.     };
  680.  
  681.     _proto.to = function to(index) {
  682.       var _this = this;
  683.  
  684.       this._activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
  685.  
  686.       var activeIndex = this._getItemIndex(this._activeElement);
  687.  
  688.       if (index > this._items.length - 1 || index < 0) {
  689.         return;
  690.       }
  691.  
  692.       if (this._isSliding) {
  693.         $$$1(this._element).one(Event.SLID, function () {
  694.           return _this.to(index);
  695.         });
  696.         return;
  697.       }
  698.  
  699.       if (activeIndex === index) {
  700.         this.pause();
  701.         this.cycle();
  702.         return;
  703.       }
  704.  
  705.       var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
  706.  
  707.       this._slide(direction, this._items[index]);
  708.     };
  709.  
  710.     _proto.dispose = function dispose() {
  711.       $$$1(this._element).off(EVENT_KEY);
  712.       $$$1.removeData(this._element, DATA_KEY);
  713.       this._items = null;
  714.       this._config = null;
  715.       this._element = null;
  716.       this._interval = null;
  717.       this._isPaused = null;
  718.       this._isSliding = null;
  719.       this._activeElement = null;
  720.       this._indicatorsElement = null;
  721.     }; // Private
  722.  
  723.  
  724.     _proto._getConfig = function _getConfig(config) {
  725.       config = _extends({}, Default, config);
  726.       Util.typeCheckConfig(NAME, config, DefaultType);
  727.       return config;
  728.     };
  729.  
  730.     _proto._addEventListeners = function _addEventListeners() {
  731.       var _this2 = this;
  732.  
  733.       if (this._config.keyboard) {
  734.         $$$1(this._element).on(Event.KEYDOWN, function (event) {
  735.           return _this2._keydown(event);
  736.         });
  737.       }
  738.  
  739.       if (this._config.pause === 'hover') {
  740.         $$$1(this._element).on(Event.MOUSEENTER, function (event) {
  741.           return _this2.pause(event);
  742.         }).on(Event.MOUSELEAVE, function (event) {
  743.           return _this2.cycle(event);
  744.         });
  745.  
  746.         if ('ontouchstart' in document.documentElement) {
  747.           // If it's a touch-enabled device, mouseenter/leave are fired as
  748.           // part of the mouse compatibility events on first tap - the carousel
  749.           // would stop cycling until user tapped out of it;
  750.           // here, we listen for touchend, explicitly pause the carousel
  751.           // (as if it's the second time we tap on it, mouseenter compat event
  752.           // is NOT fired) and after a timeout (to allow for mouse compatibility
  753.           // events to fire) we explicitly restart cycling
  754.           $$$1(this._element).on(Event.TOUCHEND, function () {
  755.             _this2.pause();
  756.  
  757.             if (_this2.touchTimeout) {
  758.               clearTimeout(_this2.touchTimeout);
  759.             }
  760.  
  761.             _this2.touchTimeout = setTimeout(function (event) {
  762.               return _this2.cycle(event);
  763.             }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
  764.           });
  765.         }
  766.       }
  767.     };
  768.  
  769.     _proto._keydown = function _keydown(event) {
  770.       if (/input|textarea/i.test(event.target.tagName)) {
  771.         return;
  772.       }
  773.  
  774.       switch (event.which) {
  775.         case ARROW_LEFT_KEYCODE:
  776.           event.preventDefault();
  777.           this.prev();
  778.           break;
  779.  
  780.         case ARROW_RIGHT_KEYCODE:
  781.           event.preventDefault();
  782.           this.next();
  783.           break;
  784.  
  785.         default:
  786.       }
  787.     };
  788.  
  789.     _proto._getItemIndex = function _getItemIndex(element) {
  790.       this._items = $$$1.makeArray($$$1(element).parent().find(Selector.ITEM));
  791.       return this._items.indexOf(element);
  792.     };
  793.  
  794.     _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
  795.       var isNextDirection = direction === Direction.NEXT;
  796.       var isPrevDirection = direction === Direction.PREV;
  797.  
  798.       var activeIndex = this._getItemIndex(activeElement);
  799.  
  800.       var lastItemIndex = this._items.length - 1;
  801.       var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
  802.  
  803.       if (isGoingToWrap && !this._config.wrap) {
  804.         return activeElement;
  805.       }
  806.  
  807.       var delta = direction === Direction.PREV ? -1 : 1;
  808.       var itemIndex = (activeIndex + delta) % this._items.length;
  809.       return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
  810.     };
  811.  
  812.     _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
  813.       var targetIndex = this._getItemIndex(relatedTarget);
  814.  
  815.       var fromIndex = this._getItemIndex($$$1(this._element).find(Selector.ACTIVE_ITEM)[0]);
  816.  
  817.       var slideEvent = $$$1.Event(Event.SLIDE, {
  818.         relatedTarget: relatedTarget,
  819.         direction: eventDirectionName,
  820.         from: fromIndex,
  821.         to: targetIndex
  822.       });
  823.       $$$1(this._element).trigger(slideEvent);
  824.       return slideEvent;
  825.     };
  826.  
  827.     _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
  828.       if (this._indicatorsElement) {
  829.         $$$1(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
  830.  
  831.         var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
  832.  
  833.         if (nextIndicator) {
  834.           $$$1(nextIndicator).addClass(ClassName.ACTIVE);
  835.         }
  836.       }
  837.     };
  838.  
  839.     _proto._slide = function _slide(direction, element) {
  840.       var _this3 = this;
  841.  
  842.       var activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
  843.  
  844.       var activeElementIndex = this._getItemIndex(activeElement);
  845.  
  846.       var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
  847.  
  848.       var nextElementIndex = this._getItemIndex(nextElement);
  849.  
  850.       var isCycling = Boolean(this._interval);
  851.       var directionalClassName;
  852.       var orderClassName;
  853.       var eventDirectionName;
  854.  
  855.       if (direction === Direction.NEXT) {
  856.         directionalClassName = ClassName.LEFT;
  857.         orderClassName = ClassName.NEXT;
  858.         eventDirectionName = Direction.LEFT;
  859.       } else {
  860.         directionalClassName = ClassName.RIGHT;
  861.         orderClassName = ClassName.PREV;
  862.         eventDirectionName = Direction.RIGHT;
  863.       }
  864.  
  865.       if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
  866.         this._isSliding = false;
  867.         return;
  868.       }
  869.  
  870.       var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
  871.  
  872.       if (slideEvent.isDefaultPrevented()) {
  873.         return;
  874.       }
  875.  
  876.       if (!activeElement || !nextElement) {
  877.         // Some weirdness is happening, so we bail
  878.         return;
  879.       }
  880.  
  881.       this._isSliding = true;
  882.  
  883.       if (isCycling) {
  884.         this.pause();
  885.       }
  886.  
  887.       this._setActiveIndicatorElement(nextElement);
  888.  
  889.       var slidEvent = $$$1.Event(Event.SLID, {
  890.         relatedTarget: nextElement,
  891.         direction: eventDirectionName,
  892.         from: activeElementIndex,
  893.         to: nextElementIndex
  894.       });
  895.  
  896.       if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.SLIDE)) {
  897.         $$$1(nextElement).addClass(orderClassName);
  898.         Util.reflow(nextElement);
  899.         $$$1(activeElement).addClass(directionalClassName);
  900.         $$$1(nextElement).addClass(directionalClassName);
  901.         $$$1(activeElement).one(Util.TRANSITION_END, function () {
  902.           $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
  903.           $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
  904.           _this3._isSliding = false;
  905.           setTimeout(function () {
  906.             return $$$1(_this3._element).trigger(slidEvent);
  907.           }, 0);
  908.         }).emulateTransitionEnd(TRANSITION_DURATION);
  909.       } else {
  910.         $$$1(activeElement).removeClass(ClassName.ACTIVE);
  911.         $$$1(nextElement).addClass(ClassName.ACTIVE);
  912.         this._isSliding = false;
  913.         $$$1(this._element).trigger(slidEvent);
  914.       }
  915.  
  916.       if (isCycling) {
  917.         this.cycle();
  918.       }
  919.     }; // Static
  920.  
  921.  
  922.     Carousel._jQueryInterface = function _jQueryInterface(config) {
  923.       return this.each(function () {
  924.         var data = $$$1(this).data(DATA_KEY);
  925.  
  926.         var _config = _extends({}, Default, $$$1(this).data());
  927.  
  928.         if (typeof config === 'object') {
  929.           _config = _extends({}, _config, config);
  930.         }
  931.  
  932.         var action = typeof config === 'string' ? config : _config.slide;
  933.  
  934.         if (!data) {
  935.           data = new Carousel(this, _config);
  936.           $$$1(this).data(DATA_KEY, data);
  937.         }
  938.  
  939.         if (typeof config === 'number') {
  940.           data.to(config);
  941.         } else if (typeof action === 'string') {
  942.           if (typeof data[action] === 'undefined') {
  943.             throw new TypeError("No method named \"" + action + "\"");
  944.           }
  945.  
  946.           data[action]();
  947.         } else if (_config.interval) {
  948.           data.pause();
  949.           data.cycle();
  950.         }
  951.       });
  952.     };
  953.  
  954.     Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
  955.       var selector = Util.getSelectorFromElement(this);
  956.  
  957.       if (!selector) {
  958.         return;
  959.       }
  960.  
  961.       var target = $$$1(selector)[0];
  962.  
  963.       if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
  964.         return;
  965.       }
  966.  
  967.       var config = _extends({}, $$$1(target).data(), $$$1(this).data());
  968.       var slideIndex = this.getAttribute('data-slide-to');
  969.  
  970.       if (slideIndex) {
  971.         config.interval = false;
  972.       }
  973.  
  974.       Carousel._jQueryInterface.call($$$1(target), config);
  975.  
  976.       if (slideIndex) {
  977.         $$$1(target).data(DATA_KEY).to(slideIndex);
  978.       }
  979.  
  980.       event.preventDefault();
  981.     };
  982.  
  983.     _createClass(Carousel, null, [{
  984.       key: "VERSION",
  985.       get: function get() {
  986.         return VERSION;
  987.       }
  988.     }, {
  989.       key: "Default",
  990.       get: function get() {
  991.         return Default;
  992.       }
  993.     }]);
  994.     return Carousel;
  995.   }();
  996.   /**
  997.    * ------------------------------------------------------------------------
  998.    * Data Api implementation
  999.    * ------------------------------------------------------------------------
  1000.    */
  1001.  
  1002.  
  1003.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
  1004.   $$$1(window).on(Event.LOAD_DATA_API, function () {
  1005.     $$$1(Selector.DATA_RIDE).each(function () {
  1006.       var $carousel = $$$1(this);
  1007.  
  1008.       Carousel._jQueryInterface.call($carousel, $carousel.data());
  1009.     });
  1010.   });
  1011.   /**
  1012.    * ------------------------------------------------------------------------
  1013.    * jQuery
  1014.    * ------------------------------------------------------------------------
  1015.    */
  1016.  
  1017.   $$$1.fn[NAME] = Carousel._jQueryInterface;
  1018.   $$$1.fn[NAME].Constructor = Carousel;
  1019.  
  1020.   $$$1.fn[NAME].noConflict = function () {
  1021.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  1022.     return Carousel._jQueryInterface;
  1023.   };
  1024.  
  1025.   return Carousel;
  1026. }($);
  1027.  
  1028. /**
  1029.  * --------------------------------------------------------------------------
  1030.  * Bootstrap (v4.0.0): collapse.js
  1031.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  1032.  * --------------------------------------------------------------------------
  1033.  */
  1034.  
  1035. var Collapse = function ($$$1) {
  1036.   /**
  1037.    * ------------------------------------------------------------------------
  1038.    * Constants
  1039.    * ------------------------------------------------------------------------
  1040.    */
  1041.   var NAME = 'collapse';
  1042.   var VERSION = '4.0.0';
  1043.   var DATA_KEY = 'bs.collapse';
  1044.   var EVENT_KEY = "." + DATA_KEY;
  1045.   var DATA_API_KEY = '.data-api';
  1046.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  1047.   var TRANSITION_DURATION = 600;
  1048.   var Default = {
  1049.     toggle: true,
  1050.     parent: ''
  1051.   };
  1052.   var DefaultType = {
  1053.     toggle: 'boolean',
  1054.     parent: '(string|element)'
  1055.   };
  1056.   var Event = {
  1057.     SHOW: "show" + EVENT_KEY,
  1058.     SHOWN: "shown" + EVENT_KEY,
  1059.     HIDE: "hide" + EVENT_KEY,
  1060.     HIDDEN: "hidden" + EVENT_KEY,
  1061.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
  1062.   };
  1063.   var ClassName = {
  1064.     SHOW: 'show',
  1065.     COLLAPSE: 'collapse',
  1066.     COLLAPSING: 'collapsing',
  1067.     COLLAPSED: 'collapsed'
  1068.   };
  1069.   var Dimension = {
  1070.     WIDTH: 'width',
  1071.     HEIGHT: 'height'
  1072.   };
  1073.   var Selector = {
  1074.     ACTIVES: '.show, .collapsing',
  1075.     DATA_TOGGLE: '[data-toggle="collapse"]'
  1076.     /**
  1077.      * ------------------------------------------------------------------------
  1078.      * Class Definition
  1079.      * ------------------------------------------------------------------------
  1080.      */
  1081.  
  1082.   };
  1083.  
  1084.   var Collapse =
  1085.   /*#__PURE__*/
  1086.   function () {
  1087.     function Collapse(element, config) {
  1088.       this._isTransitioning = false;
  1089.       this._element = element;
  1090.       this._config = this._getConfig(config);
  1091.       this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
  1092.       var tabToggles = $$$1(Selector.DATA_TOGGLE);
  1093.  
  1094.       for (var i = 0; i < tabToggles.length; i++) {
  1095.         var elem = tabToggles[i];
  1096.         var selector = Util.getSelectorFromElement(elem);
  1097.  
  1098.         if (selector !== null && $$$1(selector).filter(element).length > 0) {
  1099.           this._selector = selector;
  1100.  
  1101.           this._triggerArray.push(elem);
  1102.         }
  1103.       }
  1104.  
  1105.       this._parent = this._config.parent ? this._getParent() : null;
  1106.  
  1107.       if (!this._config.parent) {
  1108.         this._addAriaAndCollapsedClass(this._element, this._triggerArray);
  1109.       }
  1110.  
  1111.       if (this._config.toggle) {
  1112.         this.toggle();
  1113.       }
  1114.     } // Getters
  1115.  
  1116.  
  1117.     var _proto = Collapse.prototype;
  1118.  
  1119.     // Public
  1120.     _proto.toggle = function toggle() {
  1121.       if ($$$1(this._element).hasClass(ClassName.SHOW)) {
  1122.         this.hide();
  1123.       } else {
  1124.         this.show();
  1125.       }
  1126.     };
  1127.  
  1128.     _proto.show = function show() {
  1129.       var _this = this;
  1130.  
  1131.       if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
  1132.         return;
  1133.       }
  1134.  
  1135.       var actives;
  1136.       var activesData;
  1137.  
  1138.       if (this._parent) {
  1139.         actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
  1140.  
  1141.         if (actives.length === 0) {
  1142.           actives = null;
  1143.         }
  1144.       }
  1145.  
  1146.       if (actives) {
  1147.         activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
  1148.  
  1149.         if (activesData && activesData._isTransitioning) {
  1150.           return;
  1151.         }
  1152.       }
  1153.  
  1154.       var startEvent = $$$1.Event(Event.SHOW);
  1155.       $$$1(this._element).trigger(startEvent);
  1156.  
  1157.       if (startEvent.isDefaultPrevented()) {
  1158.         return;
  1159.       }
  1160.  
  1161.       if (actives) {
  1162.         Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
  1163.  
  1164.         if (!activesData) {
  1165.           $$$1(actives).data(DATA_KEY, null);
  1166.         }
  1167.       }
  1168.  
  1169.       var dimension = this._getDimension();
  1170.  
  1171.       $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
  1172.       this._element.style[dimension] = 0;
  1173.  
  1174.       if (this._triggerArray.length > 0) {
  1175.         $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
  1176.       }
  1177.  
  1178.       this.setTransitioning(true);
  1179.  
  1180.       var complete = function complete() {
  1181.         $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
  1182.         _this._element.style[dimension] = '';
  1183.  
  1184.         _this.setTransitioning(false);
  1185.  
  1186.         $$$1(_this._element).trigger(Event.SHOWN);
  1187.       };
  1188.  
  1189.       if (!Util.supportsTransitionEnd()) {
  1190.         complete();
  1191.         return;
  1192.       }
  1193.  
  1194.       var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
  1195.       var scrollSize = "scroll" + capitalizedDimension;
  1196.       $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
  1197.       this._element.style[dimension] = this._element[scrollSize] + "px";
  1198.     };
  1199.  
  1200.     _proto.hide = function hide() {
  1201.       var _this2 = this;
  1202.  
  1203.       if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
  1204.         return;
  1205.       }
  1206.  
  1207.       var startEvent = $$$1.Event(Event.HIDE);
  1208.       $$$1(this._element).trigger(startEvent);
  1209.  
  1210.       if (startEvent.isDefaultPrevented()) {
  1211.         return;
  1212.       }
  1213.  
  1214.       var dimension = this._getDimension();
  1215.  
  1216.       this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
  1217.       Util.reflow(this._element);
  1218.       $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
  1219.  
  1220.       if (this._triggerArray.length > 0) {
  1221.         for (var i = 0; i < this._triggerArray.length; i++) {
  1222.           var trigger = this._triggerArray[i];
  1223.           var selector = Util.getSelectorFromElement(trigger);
  1224.  
  1225.           if (selector !== null) {
  1226.             var $elem = $$$1(selector);
  1227.  
  1228.             if (!$elem.hasClass(ClassName.SHOW)) {
  1229.               $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
  1230.             }
  1231.           }
  1232.         }
  1233.       }
  1234.  
  1235.       this.setTransitioning(true);
  1236.  
  1237.       var complete = function complete() {
  1238.         _this2.setTransitioning(false);
  1239.  
  1240.         $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
  1241.       };
  1242.  
  1243.       this._element.style[dimension] = '';
  1244.  
  1245.       if (!Util.supportsTransitionEnd()) {
  1246.         complete();
  1247.         return;
  1248.       }
  1249.  
  1250.       $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
  1251.     };
  1252.  
  1253.     _proto.setTransitioning = function setTransitioning(isTransitioning) {
  1254.       this._isTransitioning = isTransitioning;
  1255.     };
  1256.  
  1257.     _proto.dispose = function dispose() {
  1258.       $$$1.removeData(this._element, DATA_KEY);
  1259.       this._config = null;
  1260.       this._parent = null;
  1261.       this._element = null;
  1262.       this._triggerArray = null;
  1263.       this._isTransitioning = null;
  1264.     }; // Private
  1265.  
  1266.  
  1267.     _proto._getConfig = function _getConfig(config) {
  1268.       config = _extends({}, Default, config);
  1269.       config.toggle = Boolean(config.toggle); // Coerce string values
  1270.  
  1271.       Util.typeCheckConfig(NAME, config, DefaultType);
  1272.       return config;
  1273.     };
  1274.  
  1275.     _proto._getDimension = function _getDimension() {
  1276.       var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
  1277.       return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
  1278.     };
  1279.  
  1280.     _proto._getParent = function _getParent() {
  1281.       var _this3 = this;
  1282.  
  1283.       var parent = null;
  1284.  
  1285.       if (Util.isElement(this._config.parent)) {
  1286.         parent = this._config.parent; // It's a jQuery object
  1287.  
  1288.         if (typeof this._config.parent.jquery !== 'undefined') {
  1289.           parent = this._config.parent[0];
  1290.         }
  1291.       } else {
  1292.         parent = $$$1(this._config.parent)[0];
  1293.       }
  1294.  
  1295.       var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
  1296.       $$$1(parent).find(selector).each(function (i, element) {
  1297.         _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
  1298.       });
  1299.       return parent;
  1300.     };
  1301.  
  1302.     _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
  1303.       if (element) {
  1304.         var isOpen = $$$1(element).hasClass(ClassName.SHOW);
  1305.  
  1306.         if (triggerArray.length > 0) {
  1307.           $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
  1308.         }
  1309.       }
  1310.     }; // Static
  1311.  
  1312.  
  1313.     Collapse._getTargetFromElement = function _getTargetFromElement(element) {
  1314.       var selector = Util.getSelectorFromElement(element);
  1315.       return selector ? $$$1(selector)[0] : null;
  1316.     };
  1317.  
  1318.     Collapse._jQueryInterface = function _jQueryInterface(config) {
  1319.       return this.each(function () {
  1320.         var $this = $$$1(this);
  1321.         var data = $this.data(DATA_KEY);
  1322.  
  1323.         var _config = _extends({}, Default, $this.data(), typeof config === 'object' && config);
  1324.  
  1325.         if (!data && _config.toggle && /show|hide/.test(config)) {
  1326.           _config.toggle = false;
  1327.         }
  1328.  
  1329.         if (!data) {
  1330.           data = new Collapse(this, _config);
  1331.           $this.data(DATA_KEY, data);
  1332.         }
  1333.  
  1334.         if (typeof config === 'string') {
  1335.           if (typeof data[config] === 'undefined') {
  1336.             throw new TypeError("No method named \"" + config + "\"");
  1337.           }
  1338.  
  1339.           data[config]();
  1340.         }
  1341.       });
  1342.     };
  1343.  
  1344.     _createClass(Collapse, null, [{
  1345.       key: "VERSION",
  1346.       get: function get() {
  1347.         return VERSION;
  1348.       }
  1349.     }, {
  1350.       key: "Default",
  1351.       get: function get() {
  1352.         return Default;
  1353.       }
  1354.     }]);
  1355.     return Collapse;
  1356.   }();
  1357.   /**
  1358.    * ------------------------------------------------------------------------
  1359.    * Data Api implementation
  1360.    * ------------------------------------------------------------------------
  1361.    */
  1362.  
  1363.  
  1364.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
  1365.     // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
  1366.     if (event.currentTarget.tagName === 'A') {
  1367.       event.preventDefault();
  1368.     }
  1369.  
  1370.     var $trigger = $$$1(this);
  1371.     var selector = Util.getSelectorFromElement(this);
  1372.     $$$1(selector).each(function () {
  1373.       var $target = $$$1(this);
  1374.       var data = $target.data(DATA_KEY);
  1375.       var config = data ? 'toggle' : $trigger.data();
  1376.  
  1377.       Collapse._jQueryInterface.call($target, config);
  1378.     });
  1379.   });
  1380.   /**
  1381.    * ------------------------------------------------------------------------
  1382.    * jQuery
  1383.    * ------------------------------------------------------------------------
  1384.    */
  1385.  
  1386.   $$$1.fn[NAME] = Collapse._jQueryInterface;
  1387.   $$$1.fn[NAME].Constructor = Collapse;
  1388.  
  1389.   $$$1.fn[NAME].noConflict = function () {
  1390.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  1391.     return Collapse._jQueryInterface;
  1392.   };
  1393.  
  1394.   return Collapse;
  1395. }($);
  1396.  
  1397. /**!
  1398.  * @fileOverview Kickass library to create and place poppers near their reference elements.
  1399.  * @version 1.12.9
  1400.  * @license
  1401.  * Copyright (c) 2016 Federico Zivolo and contributors
  1402.  *
  1403.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  1404.  * of this software and associated documentation files (the "Software"), to deal
  1405.  * in the Software without restriction, including without limitation the rights
  1406.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  1407.  * copies of the Software, and to permit persons to whom the Software is
  1408.  * furnished to do so, subject to the following conditions:
  1409.  *
  1410.  * The above copyright notice and this permission notice shall be included in all
  1411.  * copies or substantial portions of the Software.
  1412.  *
  1413.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  1414.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  1415.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  1416.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  1417.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  1418.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  1419.  * SOFTWARE.
  1420.  */
  1421. var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
  1422. var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
  1423. var timeoutDuration = 0;
  1424. for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
  1425.   if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
  1426.     timeoutDuration = 1;
  1427.     break;
  1428.   }
  1429. }
  1430.  
  1431. function microtaskDebounce(fn) {
  1432.   var called = false;
  1433.   return function () {
  1434.     if (called) {
  1435.       return;
  1436.     }
  1437.     called = true;
  1438.     window.Promise.resolve().then(function () {
  1439.       called = false;
  1440.       fn();
  1441.     });
  1442.   };
  1443. }
  1444.  
  1445. function taskDebounce(fn) {
  1446.   var scheduled = false;
  1447.   return function () {
  1448.     if (!scheduled) {
  1449.       scheduled = true;
  1450.       setTimeout(function () {
  1451.         scheduled = false;
  1452.         fn();
  1453.       }, timeoutDuration);
  1454.     }
  1455.   };
  1456. }
  1457.  
  1458. var supportsMicroTasks = isBrowser && window.Promise;
  1459.  
  1460. /**
  1461. * Create a debounced version of a method, that's asynchronously deferred
  1462. * but called in the minimum time possible.
  1463. *
  1464. * @method
  1465. * @memberof Popper.Utils
  1466. * @argument {Function} fn
  1467. * @returns {Function}
  1468. */
  1469. var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
  1470.  
  1471. /**
  1472.  * Check if the given variable is a function
  1473.  * @method
  1474.  * @memberof Popper.Utils
  1475.  * @argument {Any} functionToCheck - variable to check
  1476.  * @returns {Boolean} answer to: is a function?
  1477.  */
  1478. function isFunction(functionToCheck) {
  1479.   var getType = {};
  1480.   return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
  1481. }
  1482.  
  1483. /**
  1484.  * Get CSS computed property of the given element
  1485.  * @method
  1486.  * @memberof Popper.Utils
  1487.  * @argument {Eement} element
  1488.  * @argument {String} property
  1489.  */
  1490. function getStyleComputedProperty(element, property) {
  1491.   if (element.nodeType !== 1) {
  1492.     return [];
  1493.   }
  1494.   // NOTE: 1 DOM access here
  1495.   var css = getComputedStyle(element, null);
  1496.   return property ? css[property] : css;
  1497. }
  1498.  
  1499. /**
  1500.  * Returns the parentNode or the host of the element
  1501.  * @method
  1502.  * @memberof Popper.Utils
  1503.  * @argument {Element} element
  1504.  * @returns {Element} parent
  1505.  */
  1506. function getParentNode(element) {
  1507.   if (element.nodeName === 'HTML') {
  1508.     return element;
  1509.   }
  1510.   return element.parentNode || element.host;
  1511. }
  1512.  
  1513. /**
  1514.  * Returns the scrolling parent of the given element
  1515.  * @method
  1516.  * @memberof Popper.Utils
  1517.  * @argument {Element} element
  1518.  * @returns {Element} scroll parent
  1519.  */
  1520. function getScrollParent(element) {
  1521.   // Return body, `getScroll` will take care to get the correct `scrollTop` from it
  1522.   if (!element) {
  1523.     return document.body;
  1524.   }
  1525.  
  1526.   switch (element.nodeName) {
  1527.     case 'HTML':
  1528.     case 'BODY':
  1529.       return element.ownerDocument.body;
  1530.     case '#document':
  1531.       return element.body;
  1532.   }
  1533.  
  1534.   // Firefox want us to check `-x` and `-y` variations as well
  1535.  
  1536.   var _getStyleComputedProp = getStyleComputedProperty(element),
  1537.       overflow = _getStyleComputedProp.overflow,
  1538.       overflowX = _getStyleComputedProp.overflowX,
  1539.       overflowY = _getStyleComputedProp.overflowY;
  1540.  
  1541.   if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {
  1542.     return element;
  1543.   }
  1544.  
  1545.   return getScrollParent(getParentNode(element));
  1546. }
  1547.  
  1548. /**
  1549.  * Returns the offset parent of the given element
  1550.  * @method
  1551.  * @memberof Popper.Utils
  1552.  * @argument {Element} element
  1553.  * @returns {Element} offset parent
  1554.  */
  1555. function getOffsetParent(element) {
  1556.   // NOTE: 1 DOM access here
  1557.   var offsetParent = element && element.offsetParent;
  1558.   var nodeName = offsetParent && offsetParent.nodeName;
  1559.  
  1560.   if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
  1561.     if (element) {
  1562.       return element.ownerDocument.documentElement;
  1563.     }
  1564.  
  1565.     return document.documentElement;
  1566.   }
  1567.  
  1568.   // .offsetParent will return the closest TD or TABLE in case
  1569.   // no offsetParent is present, I hate this job...
  1570.   if (['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
  1571.     return getOffsetParent(offsetParent);
  1572.   }
  1573.  
  1574.   return offsetParent;
  1575. }
  1576.  
  1577. function isOffsetContainer(element) {
  1578.   var nodeName = element.nodeName;
  1579.  
  1580.   if (nodeName === 'BODY') {
  1581.     return false;
  1582.   }
  1583.   return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
  1584. }
  1585.  
  1586. /**
  1587.  * Finds the root node (document, shadowDOM root) of the given element
  1588.  * @method
  1589.  * @memberof Popper.Utils
  1590.  * @argument {Element} node
  1591.  * @returns {Element} root node
  1592.  */
  1593. function getRoot(node) {
  1594.   if (node.parentNode !== null) {
  1595.     return getRoot(node.parentNode);
  1596.   }
  1597.  
  1598.   return node;
  1599. }
  1600.  
  1601. /**
  1602.  * Finds the offset parent common to the two provided nodes
  1603.  * @method
  1604.  * @memberof Popper.Utils
  1605.  * @argument {Element} element1
  1606.  * @argument {Element} element2
  1607.  * @returns {Element} common offset parent
  1608.  */
  1609. function findCommonOffsetParent(element1, element2) {
  1610.   // This check is needed to avoid errors in case one of the elements isn't defined for any reason
  1611.   if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
  1612.     return document.documentElement;
  1613.   }
  1614.  
  1615.   // Here we make sure to give as "start" the element that comes first in the DOM
  1616.   var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
  1617.   var start = order ? element1 : element2;
  1618.   var end = order ? element2 : element1;
  1619.  
  1620.   // Get common ancestor container
  1621.   var range = document.createRange();
  1622.   range.setStart(start, 0);
  1623.   range.setEnd(end, 0);
  1624.   var commonAncestorContainer = range.commonAncestorContainer;
  1625.  
  1626.   // Both nodes are inside #document
  1627.  
  1628.   if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
  1629.     if (isOffsetContainer(commonAncestorContainer)) {
  1630.       return commonAncestorContainer;
  1631.     }
  1632.  
  1633.     return getOffsetParent(commonAncestorContainer);
  1634.   }
  1635.  
  1636.   // one of the nodes is inside shadowDOM, find which one
  1637.   var element1root = getRoot(element1);
  1638.   if (element1root.host) {
  1639.     return findCommonOffsetParent(element1root.host, element2);
  1640.   } else {
  1641.     return findCommonOffsetParent(element1, getRoot(element2).host);
  1642.   }
  1643. }
  1644.  
  1645. /**
  1646.  * Gets the scroll value of the given element in the given side (top and left)
  1647.  * @method
  1648.  * @memberof Popper.Utils
  1649.  * @argument {Element} element
  1650.  * @argument {String} side `top` or `left`
  1651.  * @returns {number} amount of scrolled pixels
  1652.  */
  1653. function getScroll(element) {
  1654.   var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
  1655.  
  1656.   var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
  1657.   var nodeName = element.nodeName;
  1658.  
  1659.   if (nodeName === 'BODY' || nodeName === 'HTML') {
  1660.     var html = element.ownerDocument.documentElement;
  1661.     var scrollingElement = element.ownerDocument.scrollingElement || html;
  1662.     return scrollingElement[upperSide];
  1663.   }
  1664.  
  1665.   return element[upperSide];
  1666. }
  1667.  
  1668. /*
  1669.  * Sum or subtract the element scroll values (left and top) from a given rect object
  1670.  * @method
  1671.  * @memberof Popper.Utils
  1672.  * @param {Object} rect - Rect object you want to change
  1673.  * @param {HTMLElement} element - The element from the function reads the scroll values
  1674.  * @param {Boolean} subtract - set to true if you want to subtract the scroll values
  1675.  * @return {Object} rect - The modifier rect object
  1676.  */
  1677. function includeScroll(rect, element) {
  1678.   var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  1679.  
  1680.   var scrollTop = getScroll(element, 'top');
  1681.   var scrollLeft = getScroll(element, 'left');
  1682.   var modifier = subtract ? -1 : 1;
  1683.   rect.top += scrollTop * modifier;
  1684.   rect.bottom += scrollTop * modifier;
  1685.   rect.left += scrollLeft * modifier;
  1686.   rect.right += scrollLeft * modifier;
  1687.   return rect;
  1688. }
  1689.  
  1690. /*
  1691.  * Helper to detect borders of a given element
  1692.  * @method
  1693.  * @memberof Popper.Utils
  1694.  * @param {CSSStyleDeclaration} styles
  1695.  * Result of `getStyleComputedProperty` on the given element
  1696.  * @param {String} axis - `x` or `y`
  1697.  * @return {number} borders - The borders size of the given axis
  1698.  */
  1699.  
  1700. function getBordersSize(styles, axis) {
  1701.   var sideA = axis === 'x' ? 'Left' : 'Top';
  1702.   var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
  1703.  
  1704.   return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
  1705. }
  1706.  
  1707. /**
  1708.  * Tells if you are running Internet Explorer 10
  1709.  * @method
  1710.  * @memberof Popper.Utils
  1711.  * @returns {Boolean} isIE10
  1712.  */
  1713. var isIE10 = undefined;
  1714.  
  1715. var isIE10$1 = function () {
  1716.   if (isIE10 === undefined) {
  1717.     isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1;
  1718.   }
  1719.   return isIE10;
  1720. };
  1721.  
  1722. function getSize(axis, body, html, computedStyle) {
  1723.   return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE10$1() ? html['offset' + axis] + computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')] + computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')] : 0);
  1724. }
  1725.  
  1726. function getWindowSizes() {
  1727.   var body = document.body;
  1728.   var html = document.documentElement;
  1729.   var computedStyle = isIE10$1() && getComputedStyle(html);
  1730.  
  1731.   return {
  1732.     height: getSize('Height', body, html, computedStyle),
  1733.     width: getSize('Width', body, html, computedStyle)
  1734.   };
  1735. }
  1736.  
  1737. var classCallCheck = function (instance, Constructor) {
  1738.   if (!(instance instanceof Constructor)) {
  1739.     throw new TypeError("Cannot call a class as a function");
  1740.   }
  1741. };
  1742.  
  1743. var createClass = function () {
  1744.   function defineProperties(target, props) {
  1745.     for (var i = 0; i < props.length; i++) {
  1746.       var descriptor = props[i];
  1747.       descriptor.enumerable = descriptor.enumerable || false;
  1748.       descriptor.configurable = true;
  1749.       if ("value" in descriptor) descriptor.writable = true;
  1750.       Object.defineProperty(target, descriptor.key, descriptor);
  1751.     }
  1752.   }
  1753.  
  1754.   return function (Constructor, protoProps, staticProps) {
  1755.     if (protoProps) defineProperties(Constructor.prototype, protoProps);
  1756.     if (staticProps) defineProperties(Constructor, staticProps);
  1757.     return Constructor;
  1758.   };
  1759. }();
  1760.  
  1761.  
  1762.  
  1763.  
  1764.  
  1765. var defineProperty = function (obj, key, value) {
  1766.   if (key in obj) {
  1767.     Object.defineProperty(obj, key, {
  1768.       value: value,
  1769.       enumerable: true,
  1770.       configurable: true,
  1771.       writable: true
  1772.     });
  1773.   } else {
  1774.     obj[key] = value;
  1775.   }
  1776.  
  1777.   return obj;
  1778. };
  1779.  
  1780. var _extends$1 = Object.assign || function (target) {
  1781.   for (var i = 1; i < arguments.length; i++) {
  1782.     var source = arguments[i];
  1783.  
  1784.     for (var key in source) {
  1785.       if (Object.prototype.hasOwnProperty.call(source, key)) {
  1786.         target[key] = source[key];
  1787.       }
  1788.     }
  1789.   }
  1790.  
  1791.   return target;
  1792. };
  1793.  
  1794. /**
  1795.  * Given element offsets, generate an output similar to getBoundingClientRect
  1796.  * @method
  1797.  * @memberof Popper.Utils
  1798.  * @argument {Object} offsets
  1799.  * @returns {Object} ClientRect like output
  1800.  */
  1801. function getClientRect(offsets) {
  1802.   return _extends$1({}, offsets, {
  1803.     right: offsets.left + offsets.width,
  1804.     bottom: offsets.top + offsets.height
  1805.   });
  1806. }
  1807.  
  1808. /**
  1809.  * Get bounding client rect of given element
  1810.  * @method
  1811.  * @memberof Popper.Utils
  1812.  * @param {HTMLElement} element
  1813.  * @return {Object} client rect
  1814.  */
  1815. function getBoundingClientRect(element) {
  1816.   var rect = {};
  1817.  
  1818.   // IE10 10 FIX: Please, don't ask, the element isn't
  1819.   // considered in DOM in some circumstances...
  1820.   // This isn't reproducible in IE10 compatibility mode of IE11
  1821.   if (isIE10$1()) {
  1822.     try {
  1823.       rect = element.getBoundingClientRect();
  1824.       var scrollTop = getScroll(element, 'top');
  1825.       var scrollLeft = getScroll(element, 'left');
  1826.       rect.top += scrollTop;
  1827.       rect.left += scrollLeft;
  1828.       rect.bottom += scrollTop;
  1829.       rect.right += scrollLeft;
  1830.     } catch (err) {}
  1831.   } else {
  1832.     rect = element.getBoundingClientRect();
  1833.   }
  1834.  
  1835.   var result = {
  1836.     left: rect.left,
  1837.     top: rect.top,
  1838.     width: rect.right - rect.left,
  1839.     height: rect.bottom - rect.top
  1840.   };
  1841.  
  1842.   // subtract scrollbar size from sizes
  1843.   var sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};
  1844.   var width = sizes.width || element.clientWidth || result.right - result.left;
  1845.   var height = sizes.height || element.clientHeight || result.bottom - result.top;
  1846.  
  1847.   var horizScrollbar = element.offsetWidth - width;
  1848.   var vertScrollbar = element.offsetHeight - height;
  1849.  
  1850.   // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
  1851.   // we make this check conditional for performance reasons
  1852.   if (horizScrollbar || vertScrollbar) {
  1853.     var styles = getStyleComputedProperty(element);
  1854.     horizScrollbar -= getBordersSize(styles, 'x');
  1855.     vertScrollbar -= getBordersSize(styles, 'y');
  1856.  
  1857.     result.width -= horizScrollbar;
  1858.     result.height -= vertScrollbar;
  1859.   }
  1860.  
  1861.   return getClientRect(result);
  1862. }
  1863.  
  1864. function getOffsetRectRelativeToArbitraryNode(children, parent) {
  1865.   var isIE10 = isIE10$1();
  1866.   var isHTML = parent.nodeName === 'HTML';
  1867.   var childrenRect = getBoundingClientRect(children);
  1868.   var parentRect = getBoundingClientRect(parent);
  1869.   var scrollParent = getScrollParent(children);
  1870.  
  1871.   var styles = getStyleComputedProperty(parent);
  1872.   var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
  1873.   var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
  1874.  
  1875.   var offsets = getClientRect({
  1876.     top: childrenRect.top - parentRect.top - borderTopWidth,
  1877.     left: childrenRect.left - parentRect.left - borderLeftWidth,
  1878.     width: childrenRect.width,
  1879.     height: childrenRect.height
  1880.   });
  1881.   offsets.marginTop = 0;
  1882.   offsets.marginLeft = 0;
  1883.  
  1884.   // Subtract margins of documentElement in case it's being used as parent
  1885.   // we do this only on HTML because it's the only element that behaves
  1886.   // differently when margins are applied to it. The margins are included in
  1887.   // the box of the documentElement, in the other cases not.
  1888.   if (!isIE10 && isHTML) {
  1889.     var marginTop = parseFloat(styles.marginTop, 10);
  1890.     var marginLeft = parseFloat(styles.marginLeft, 10);
  1891.  
  1892.     offsets.top -= borderTopWidth - marginTop;
  1893.     offsets.bottom -= borderTopWidth - marginTop;
  1894.     offsets.left -= borderLeftWidth - marginLeft;
  1895.     offsets.right -= borderLeftWidth - marginLeft;
  1896.  
  1897.     // Attach marginTop and marginLeft because in some circumstances we may need them
  1898.     offsets.marginTop = marginTop;
  1899.     offsets.marginLeft = marginLeft;
  1900.   }
  1901.  
  1902.   if (isIE10 ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
  1903.     offsets = includeScroll(offsets, parent);
  1904.   }
  1905.  
  1906.   return offsets;
  1907. }
  1908.  
  1909. function getViewportOffsetRectRelativeToArtbitraryNode(element) {
  1910.   var html = element.ownerDocument.documentElement;
  1911.   var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
  1912.   var width = Math.max(html.clientWidth, window.innerWidth || 0);
  1913.   var height = Math.max(html.clientHeight, window.innerHeight || 0);
  1914.  
  1915.   var scrollTop = getScroll(html);
  1916.   var scrollLeft = getScroll(html, 'left');
  1917.  
  1918.   var offset = {
  1919.     top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
  1920.     left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
  1921.     width: width,
  1922.     height: height
  1923.   };
  1924.  
  1925.   return getClientRect(offset);
  1926. }
  1927.  
  1928. /**
  1929.  * Check if the given element is fixed or is inside a fixed parent
  1930.  * @method
  1931.  * @memberof Popper.Utils
  1932.  * @argument {Element} element
  1933.  * @argument {Element} customContainer
  1934.  * @returns {Boolean} answer to "isFixed?"
  1935.  */
  1936. function isFixed(element) {
  1937.   var nodeName = element.nodeName;
  1938.   if (nodeName === 'BODY' || nodeName === 'HTML') {
  1939.     return false;
  1940.   }
  1941.   if (getStyleComputedProperty(element, 'position') === 'fixed') {
  1942.     return true;
  1943.   }
  1944.   return isFixed(getParentNode(element));
  1945. }
  1946.  
  1947. /**
  1948.  * Computed the boundaries limits and return them
  1949.  * @method
  1950.  * @memberof Popper.Utils
  1951.  * @param {HTMLElement} popper
  1952.  * @param {HTMLElement} reference
  1953.  * @param {number} padding
  1954.  * @param {HTMLElement} boundariesElement - Element used to define the boundaries
  1955.  * @returns {Object} Coordinates of the boundaries
  1956.  */
  1957. function getBoundaries(popper, reference, padding, boundariesElement) {
  1958.   // NOTE: 1 DOM access here
  1959.   var boundaries = { top: 0, left: 0 };
  1960.   var offsetParent = findCommonOffsetParent(popper, reference);
  1961.  
  1962.   // Handle viewport case
  1963.   if (boundariesElement === 'viewport') {
  1964.     boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent);
  1965.   } else {
  1966.     // Handle other cases based on DOM element used as boundaries
  1967.     var boundariesNode = void 0;
  1968.     if (boundariesElement === 'scrollParent') {
  1969.       boundariesNode = getScrollParent(getParentNode(reference));
  1970.       if (boundariesNode.nodeName === 'BODY') {
  1971.         boundariesNode = popper.ownerDocument.documentElement;
  1972.       }
  1973.     } else if (boundariesElement === 'window') {
  1974.       boundariesNode = popper.ownerDocument.documentElement;
  1975.     } else {
  1976.       boundariesNode = boundariesElement;
  1977.     }
  1978.  
  1979.     var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent);
  1980.  
  1981.     // In case of HTML, we need a different computation
  1982.     if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
  1983.       var _getWindowSizes = getWindowSizes(),
  1984.           height = _getWindowSizes.height,
  1985.           width = _getWindowSizes.width;
  1986.  
  1987.       boundaries.top += offsets.top - offsets.marginTop;
  1988.       boundaries.bottom = height + offsets.top;
  1989.       boundaries.left += offsets.left - offsets.marginLeft;
  1990.       boundaries.right = width + offsets.left;
  1991.     } else {
  1992.       // for all the other DOM elements, this one is good
  1993.       boundaries = offsets;
  1994.     }
  1995.   }
  1996.  
  1997.   // Add paddings
  1998.   boundaries.left += padding;
  1999.   boundaries.top += padding;
  2000.   boundaries.right -= padding;
  2001.   boundaries.bottom -= padding;
  2002.  
  2003.   return boundaries;
  2004. }
  2005.  
  2006. function getArea(_ref) {
  2007.   var width = _ref.width,
  2008.       height = _ref.height;
  2009.  
  2010.   return width * height;
  2011. }
  2012.  
  2013. /**
  2014.  * Utility used to transform the `auto` placement to the placement with more
  2015.  * available space.
  2016.  * @method
  2017.  * @memberof Popper.Utils
  2018.  * @argument {Object} data - The data object generated by update method
  2019.  * @argument {Object} options - Modifiers configuration and options
  2020.  * @returns {Object} The data object, properly modified
  2021.  */
  2022. function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
  2023.   var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
  2024.  
  2025.   if (placement.indexOf('auto') === -1) {
  2026.     return placement;
  2027.   }
  2028.  
  2029.   var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
  2030.  
  2031.   var rects = {
  2032.     top: {
  2033.       width: boundaries.width,
  2034.       height: refRect.top - boundaries.top
  2035.     },
  2036.     right: {
  2037.       width: boundaries.right - refRect.right,
  2038.       height: boundaries.height
  2039.     },
  2040.     bottom: {
  2041.       width: boundaries.width,
  2042.       height: boundaries.bottom - refRect.bottom
  2043.     },
  2044.     left: {
  2045.       width: refRect.left - boundaries.left,
  2046.       height: boundaries.height
  2047.     }
  2048.   };
  2049.  
  2050.   var sortedAreas = Object.keys(rects).map(function (key) {
  2051.     return _extends$1({
  2052.       key: key
  2053.     }, rects[key], {
  2054.       area: getArea(rects[key])
  2055.     });
  2056.   }).sort(function (a, b) {
  2057.     return b.area - a.area;
  2058.   });
  2059.  
  2060.   var filteredAreas = sortedAreas.filter(function (_ref2) {
  2061.     var width = _ref2.width,
  2062.         height = _ref2.height;
  2063.     return width >= popper.clientWidth && height >= popper.clientHeight;
  2064.   });
  2065.  
  2066.   var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
  2067.  
  2068.   var variation = placement.split('-')[1];
  2069.  
  2070.   return computedPlacement + (variation ? '-' + variation : '');
  2071. }
  2072.  
  2073. /**
  2074.  * Get offsets to the reference element
  2075.  * @method
  2076.  * @memberof Popper.Utils
  2077.  * @param {Object} state
  2078.  * @param {Element} popper - the popper element
  2079.  * @param {Element} reference - the reference element (the popper will be relative to this)
  2080.  * @returns {Object} An object containing the offsets which will be applied to the popper
  2081.  */
  2082. function getReferenceOffsets(state, popper, reference) {
  2083.   var commonOffsetParent = findCommonOffsetParent(popper, reference);
  2084.   return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent);
  2085. }
  2086.  
  2087. /**
  2088.  * Get the outer sizes of the given element (offset size + margins)
  2089.  * @method
  2090.  * @memberof Popper.Utils
  2091.  * @argument {Element} element
  2092.  * @returns {Object} object containing width and height properties
  2093.  */
  2094. function getOuterSizes(element) {
  2095.   var styles = getComputedStyle(element);
  2096.   var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
  2097.   var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
  2098.   var result = {
  2099.     width: element.offsetWidth + y,
  2100.     height: element.offsetHeight + x
  2101.   };
  2102.   return result;
  2103. }
  2104.  
  2105. /**
  2106.  * Get the opposite placement of the given one
  2107.  * @method
  2108.  * @memberof Popper.Utils
  2109.  * @argument {String} placement
  2110.  * @returns {String} flipped placement
  2111.  */
  2112. function getOppositePlacement(placement) {
  2113.   var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
  2114.   return placement.replace(/left|right|bottom|top/g, function (matched) {
  2115.     return hash[matched];
  2116.   });
  2117. }
  2118.  
  2119. /**
  2120.  * Get offsets to the popper
  2121.  * @method
  2122.  * @memberof Popper.Utils
  2123.  * @param {Object} position - CSS position the Popper will get applied
  2124.  * @param {HTMLElement} popper - the popper element
  2125.  * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
  2126.  * @param {String} placement - one of the valid placement options
  2127.  * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
  2128.  */
  2129. function getPopperOffsets(popper, referenceOffsets, placement) {
  2130.   placement = placement.split('-')[0];
  2131.  
  2132.   // Get popper node sizes
  2133.   var popperRect = getOuterSizes(popper);
  2134.  
  2135.   // Add position, width and height to our offsets object
  2136.   var popperOffsets = {
  2137.     width: popperRect.width,
  2138.     height: popperRect.height
  2139.   };
  2140.  
  2141.   // depending by the popper placement we have to compute its offsets slightly differently
  2142.   var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
  2143.   var mainSide = isHoriz ? 'top' : 'left';
  2144.   var secondarySide = isHoriz ? 'left' : 'top';
  2145.   var measurement = isHoriz ? 'height' : 'width';
  2146.   var secondaryMeasurement = !isHoriz ? 'height' : 'width';
  2147.  
  2148.   popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
  2149.   if (placement === secondarySide) {
  2150.     popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
  2151.   } else {
  2152.     popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
  2153.   }
  2154.  
  2155.   return popperOffsets;
  2156. }
  2157.  
  2158. /**
  2159.  * Mimics the `find` method of Array
  2160.  * @method
  2161.  * @memberof Popper.Utils
  2162.  * @argument {Array} arr
  2163.  * @argument prop
  2164.  * @argument value
  2165.  * @returns index or -1
  2166.  */
  2167. function find(arr, check) {
  2168.   // use native find if supported
  2169.   if (Array.prototype.find) {
  2170.     return arr.find(check);
  2171.   }
  2172.  
  2173.   // use `filter` to obtain the same behavior of `find`
  2174.   return arr.filter(check)[0];
  2175. }
  2176.  
  2177. /**
  2178.  * Return the index of the matching object
  2179.  * @method
  2180.  * @memberof Popper.Utils
  2181.  * @argument {Array} arr
  2182.  * @argument prop
  2183.  * @argument value
  2184.  * @returns index or -1
  2185.  */
  2186. function findIndex(arr, prop, value) {
  2187.   // use native findIndex if supported
  2188.   if (Array.prototype.findIndex) {
  2189.     return arr.findIndex(function (cur) {
  2190.       return cur[prop] === value;
  2191.     });
  2192.   }
  2193.  
  2194.   // use `find` + `indexOf` if `findIndex` isn't supported
  2195.   var match = find(arr, function (obj) {
  2196.     return obj[prop] === value;
  2197.   });
  2198.   return arr.indexOf(match);
  2199. }
  2200.  
  2201. /**
  2202.  * Loop trough the list of modifiers and run them in order,
  2203.  * each of them will then edit the data object.
  2204.  * @method
  2205.  * @memberof Popper.Utils
  2206.  * @param {dataObject} data
  2207.  * @param {Array} modifiers
  2208.  * @param {String} ends - Optional modifier name used as stopper
  2209.  * @returns {dataObject}
  2210.  */
  2211. function runModifiers(modifiers, data, ends) {
  2212.   var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
  2213.  
  2214.   modifiersToRun.forEach(function (modifier) {
  2215.     if (modifier['function']) {
  2216.       // eslint-disable-line dot-notation
  2217.       console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
  2218.     }
  2219.     var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
  2220.     if (modifier.enabled && isFunction(fn)) {
  2221.       // Add properties to offsets to make them a complete clientRect object
  2222.       // we do this before each modifier to make sure the previous one doesn't
  2223.       // mess with these values
  2224.       data.offsets.popper = getClientRect(data.offsets.popper);
  2225.       data.offsets.reference = getClientRect(data.offsets.reference);
  2226.  
  2227.       data = fn(data, modifier);
  2228.     }
  2229.   });
  2230.  
  2231.   return data;
  2232. }
  2233.  
  2234. /**
  2235.  * Updates the position of the popper, computing the new offsets and applying
  2236.  * the new style.<br />
  2237.  * Prefer `scheduleUpdate` over `update` because of performance reasons.
  2238.  * @method
  2239.  * @memberof Popper
  2240.  */
  2241. function update() {
  2242.   // if popper is destroyed, don't perform any further update
  2243.   if (this.state.isDestroyed) {
  2244.     return;
  2245.   }
  2246.  
  2247.   var data = {
  2248.     instance: this,
  2249.     styles: {},
  2250.     arrowStyles: {},
  2251.     attributes: {},
  2252.     flipped: false,
  2253.     offsets: {}
  2254.   };
  2255.  
  2256.   // compute reference element offsets
  2257.   data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference);
  2258.  
  2259.   // compute auto placement, store placement inside the data object,
  2260.   // modifiers will be able to edit `placement` if needed
  2261.   // and refer to originalPlacement to know the original value
  2262.   data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
  2263.  
  2264.   // store the computed placement inside `originalPlacement`
  2265.   data.originalPlacement = data.placement;
  2266.  
  2267.   // compute the popper offsets
  2268.   data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
  2269.   data.offsets.popper.position = 'absolute';
  2270.  
  2271.   // run the modifiers
  2272.   data = runModifiers(this.modifiers, data);
  2273.  
  2274.   // the first `update` will call `onCreate` callback
  2275.   // the other ones will call `onUpdate` callback
  2276.   if (!this.state.isCreated) {
  2277.     this.state.isCreated = true;
  2278.     this.options.onCreate(data);
  2279.   } else {
  2280.     this.options.onUpdate(data);
  2281.   }
  2282. }
  2283.  
  2284. /**
  2285.  * Helper used to know if the given modifier is enabled.
  2286.  * @method
  2287.  * @memberof Popper.Utils
  2288.  * @returns {Boolean}
  2289.  */
  2290. function isModifierEnabled(modifiers, modifierName) {
  2291.   return modifiers.some(function (_ref) {
  2292.     var name = _ref.name,
  2293.         enabled = _ref.enabled;
  2294.     return enabled && name === modifierName;
  2295.   });
  2296. }
  2297.  
  2298. /**
  2299.  * Get the prefixed supported property name
  2300.  * @method
  2301.  * @memberof Popper.Utils
  2302.  * @argument {String} property (camelCase)
  2303.  * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
  2304.  */
  2305. function getSupportedPropertyName(property) {
  2306.   var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
  2307.   var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
  2308.  
  2309.   for (var i = 0; i < prefixes.length - 1; i++) {
  2310.     var prefix = prefixes[i];
  2311.     var toCheck = prefix ? '' + prefix + upperProp : property;
  2312.     if (typeof document.body.style[toCheck] !== 'undefined') {
  2313.       return toCheck;
  2314.     }
  2315.   }
  2316.   return null;
  2317. }
  2318.  
  2319. /**
  2320.  * Destroy the popper
  2321.  * @method
  2322.  * @memberof Popper
  2323.  */
  2324. function destroy() {
  2325.   this.state.isDestroyed = true;
  2326.  
  2327.   // touch DOM only if `applyStyle` modifier is enabled
  2328.   if (isModifierEnabled(this.modifiers, 'applyStyle')) {
  2329.     this.popper.removeAttribute('x-placement');
  2330.     this.popper.style.left = '';
  2331.     this.popper.style.position = '';
  2332.     this.popper.style.top = '';
  2333.     this.popper.style[getSupportedPropertyName('transform')] = '';
  2334.   }
  2335.  
  2336.   this.disableEventListeners();
  2337.  
  2338.   // remove the popper if user explicity asked for the deletion on destroy
  2339.   // do not use `remove` because IE11 doesn't support it
  2340.   if (this.options.removeOnDestroy) {
  2341.     this.popper.parentNode.removeChild(this.popper);
  2342.   }
  2343.   return this;
  2344. }
  2345.  
  2346. /**
  2347.  * Get the window associated with the element
  2348.  * @argument {Element} element
  2349.  * @returns {Window}
  2350.  */
  2351. function getWindow(element) {
  2352.   var ownerDocument = element.ownerDocument;
  2353.   return ownerDocument ? ownerDocument.defaultView : window;
  2354. }
  2355.  
  2356. function attachToScrollParents(scrollParent, event, callback, scrollParents) {
  2357.   var isBody = scrollParent.nodeName === 'BODY';
  2358.   var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
  2359.   target.addEventListener(event, callback, { passive: true });
  2360.  
  2361.   if (!isBody) {
  2362.     attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
  2363.   }
  2364.   scrollParents.push(target);
  2365. }
  2366.  
  2367. /**
  2368.  * Setup needed event listeners used to update the popper position
  2369.  * @method
  2370.  * @memberof Popper.Utils
  2371.  * @private
  2372.  */
  2373. function setupEventListeners(reference, options, state, updateBound) {
  2374.   // Resize event listener on window
  2375.   state.updateBound = updateBound;
  2376.   getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
  2377.  
  2378.   // Scroll event listener on scroll parents
  2379.   var scrollElement = getScrollParent(reference);
  2380.   attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
  2381.   state.scrollElement = scrollElement;
  2382.   state.eventsEnabled = true;
  2383.  
  2384.   return state;
  2385. }
  2386.  
  2387. /**
  2388.  * It will add resize/scroll events and start recalculating
  2389.  * position of the popper element when they are triggered.
  2390.  * @method
  2391.  * @memberof Popper
  2392.  */
  2393. function enableEventListeners() {
  2394.   if (!this.state.eventsEnabled) {
  2395.     this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
  2396.   }
  2397. }
  2398.  
  2399. /**
  2400.  * Remove event listeners used to update the popper position
  2401.  * @method
  2402.  * @memberof Popper.Utils
  2403.  * @private
  2404.  */
  2405. function removeEventListeners(reference, state) {
  2406.   // Remove resize event listener on window
  2407.   getWindow(reference).removeEventListener('resize', state.updateBound);
  2408.  
  2409.   // Remove scroll event listener on scroll parents
  2410.   state.scrollParents.forEach(function (target) {
  2411.     target.removeEventListener('scroll', state.updateBound);
  2412.   });
  2413.  
  2414.   // Reset state
  2415.   state.updateBound = null;
  2416.   state.scrollParents = [];
  2417.   state.scrollElement = null;
  2418.   state.eventsEnabled = false;
  2419.   return state;
  2420. }
  2421.  
  2422. /**
  2423.  * It will remove resize/scroll events and won't recalculate popper position
  2424.  * when they are triggered. It also won't trigger onUpdate callback anymore,
  2425.  * unless you call `update` method manually.
  2426.  * @method
  2427.  * @memberof Popper
  2428.  */
  2429. function disableEventListeners() {
  2430.   if (this.state.eventsEnabled) {
  2431.     cancelAnimationFrame(this.scheduleUpdate);
  2432.     this.state = removeEventListeners(this.reference, this.state);
  2433.   }
  2434. }
  2435.  
  2436. /**
  2437.  * Tells if a given input is a number
  2438.  * @method
  2439.  * @memberof Popper.Utils
  2440.  * @param {*} input to check
  2441.  * @return {Boolean}
  2442.  */
  2443. function isNumeric(n) {
  2444.   return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
  2445. }
  2446.  
  2447. /**
  2448.  * Set the style to the given popper
  2449.  * @method
  2450.  * @memberof Popper.Utils
  2451.  * @argument {Element} element - Element to apply the style to
  2452.  * @argument {Object} styles
  2453.  * Object with a list of properties and values which will be applied to the element
  2454.  */
  2455. function setStyles(element, styles) {
  2456.   Object.keys(styles).forEach(function (prop) {
  2457.     var unit = '';
  2458.     // add unit if the value is numeric and is one of the following
  2459.     if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
  2460.       unit = 'px';
  2461.     }
  2462.     element.style[prop] = styles[prop] + unit;
  2463.   });
  2464. }
  2465.  
  2466. /**
  2467.  * Set the attributes to the given popper
  2468.  * @method
  2469.  * @memberof Popper.Utils
  2470.  * @argument {Element} element - Element to apply the attributes to
  2471.  * @argument {Object} styles
  2472.  * Object with a list of properties and values which will be applied to the element
  2473.  */
  2474. function setAttributes(element, attributes) {
  2475.   Object.keys(attributes).forEach(function (prop) {
  2476.     var value = attributes[prop];
  2477.     if (value !== false) {
  2478.       element.setAttribute(prop, attributes[prop]);
  2479.     } else {
  2480.       element.removeAttribute(prop);
  2481.     }
  2482.   });
  2483. }
  2484.  
  2485. /**
  2486.  * @function
  2487.  * @memberof Modifiers
  2488.  * @argument {Object} data - The data object generated by `update` method
  2489.  * @argument {Object} data.styles - List of style properties - values to apply to popper element
  2490.  * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
  2491.  * @argument {Object} options - Modifiers configuration and options
  2492.  * @returns {Object} The same data object
  2493.  */
  2494. function applyStyle(data) {
  2495.   // any property present in `data.styles` will be applied to the popper,
  2496.   // in this way we can make the 3rd party modifiers add custom styles to it
  2497.   // Be aware, modifiers could override the properties defined in the previous
  2498.   // lines of this modifier!
  2499.   setStyles(data.instance.popper, data.styles);
  2500.  
  2501.   // any property present in `data.attributes` will be applied to the popper,
  2502.   // they will be set as HTML attributes of the element
  2503.   setAttributes(data.instance.popper, data.attributes);
  2504.  
  2505.   // if arrowElement is defined and arrowStyles has some properties
  2506.   if (data.arrowElement && Object.keys(data.arrowStyles).length) {
  2507.     setStyles(data.arrowElement, data.arrowStyles);
  2508.   }
  2509.  
  2510.   return data;
  2511. }
  2512.  
  2513. /**
  2514.  * Set the x-placement attribute before everything else because it could be used
  2515.  * to add margins to the popper margins needs to be calculated to get the
  2516.  * correct popper offsets.
  2517.  * @method
  2518.  * @memberof Popper.modifiers
  2519.  * @param {HTMLElement} reference - The reference element used to position the popper
  2520.  * @param {HTMLElement} popper - The HTML element used as popper.
  2521.  * @param {Object} options - Popper.js options
  2522.  */
  2523. function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
  2524.   // compute reference element offsets
  2525.   var referenceOffsets = getReferenceOffsets(state, popper, reference);
  2526.  
  2527.   // compute auto placement, store placement inside the data object,
  2528.   // modifiers will be able to edit `placement` if needed
  2529.   // and refer to originalPlacement to know the original value
  2530.   var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
  2531.  
  2532.   popper.setAttribute('x-placement', placement);
  2533.  
  2534.   // Apply `position` to popper before anything else because
  2535.   // without the position applied we can't guarantee correct computations
  2536.   setStyles(popper, { position: 'absolute' });
  2537.  
  2538.   return options;
  2539. }
  2540.  
  2541. /**
  2542.  * @function
  2543.  * @memberof Modifiers
  2544.  * @argument {Object} data - The data object generated by `update` method
  2545.  * @argument {Object} options - Modifiers configuration and options
  2546.  * @returns {Object} The data object, properly modified
  2547.  */
  2548. function computeStyle(data, options) {
  2549.   var x = options.x,
  2550.       y = options.y;
  2551.   var popper = data.offsets.popper;
  2552.  
  2553.   // Remove this legacy support in Popper.js v2
  2554.  
  2555.   var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
  2556.     return modifier.name === 'applyStyle';
  2557.   }).gpuAcceleration;
  2558.   if (legacyGpuAccelerationOption !== undefined) {
  2559.     console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
  2560.   }
  2561.   var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
  2562.  
  2563.   var offsetParent = getOffsetParent(data.instance.popper);
  2564.   var offsetParentRect = getBoundingClientRect(offsetParent);
  2565.  
  2566.   // Styles
  2567.   var styles = {
  2568.     position: popper.position
  2569.   };
  2570.  
  2571.   // floor sides to avoid blurry text
  2572.   var offsets = {
  2573.     left: Math.floor(popper.left),
  2574.     top: Math.floor(popper.top),
  2575.     bottom: Math.floor(popper.bottom),
  2576.     right: Math.floor(popper.right)
  2577.   };
  2578.  
  2579.   var sideA = x === 'bottom' ? 'top' : 'bottom';
  2580.   var sideB = y === 'right' ? 'left' : 'right';
  2581.  
  2582.   // if gpuAcceleration is set to `true` and transform is supported,
  2583.   //  we use `translate3d` to apply the position to the popper we
  2584.   // automatically use the supported prefixed version if needed
  2585.   var prefixedProperty = getSupportedPropertyName('transform');
  2586.  
  2587.   // now, let's make a step back and look at this code closely (wtf?)
  2588.   // If the content of the popper grows once it's been positioned, it
  2589.   // may happen that the popper gets misplaced because of the new content
  2590.   // overflowing its reference element
  2591.   // To avoid this problem, we provide two options (x and y), which allow
  2592.   // the consumer to define the offset origin.
  2593.   // If we position a popper on top of a reference element, we can set
  2594.   // `x` to `top` to make the popper grow towards its top instead of
  2595.   // its bottom.
  2596.   var left = void 0,
  2597.       top = void 0;
  2598.   if (sideA === 'bottom') {
  2599.     top = -offsetParentRect.height + offsets.bottom;
  2600.   } else {
  2601.     top = offsets.top;
  2602.   }
  2603.   if (sideB === 'right') {
  2604.     left = -offsetParentRect.width + offsets.right;
  2605.   } else {
  2606.     left = offsets.left;
  2607.   }
  2608.   if (gpuAcceleration && prefixedProperty) {
  2609.     styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
  2610.     styles[sideA] = 0;
  2611.     styles[sideB] = 0;
  2612.     styles.willChange = 'transform';
  2613.   } else {
  2614.     // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
  2615.     var invertTop = sideA === 'bottom' ? -1 : 1;
  2616.     var invertLeft = sideB === 'right' ? -1 : 1;
  2617.     styles[sideA] = top * invertTop;
  2618.     styles[sideB] = left * invertLeft;
  2619.     styles.willChange = sideA + ', ' + sideB;
  2620.   }
  2621.  
  2622.   // Attributes
  2623.   var attributes = {
  2624.     'x-placement': data.placement
  2625.   };
  2626.  
  2627.   // Update `data` attributes, styles and arrowStyles
  2628.   data.attributes = _extends$1({}, attributes, data.attributes);
  2629.   data.styles = _extends$1({}, styles, data.styles);
  2630.   data.arrowStyles = _extends$1({}, data.offsets.arrow, data.arrowStyles);
  2631.  
  2632.   return data;
  2633. }
  2634.  
  2635. /**
  2636.  * Helper used to know if the given modifier depends from another one.<br />
  2637.  * It checks if the needed modifier is listed and enabled.
  2638.  * @method
  2639.  * @memberof Popper.Utils
  2640.  * @param {Array} modifiers - list of modifiers
  2641.  * @param {String} requestingName - name of requesting modifier
  2642.  * @param {String} requestedName - name of requested modifier
  2643.  * @returns {Boolean}
  2644.  */
  2645. function isModifierRequired(modifiers, requestingName, requestedName) {
  2646.   var requesting = find(modifiers, function (_ref) {
  2647.     var name = _ref.name;
  2648.     return name === requestingName;
  2649.   });
  2650.  
  2651.   var isRequired = !!requesting && modifiers.some(function (modifier) {
  2652.     return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
  2653.   });
  2654.  
  2655.   if (!isRequired) {
  2656.     var _requesting = '`' + requestingName + '`';
  2657.     var requested = '`' + requestedName + '`';
  2658.     console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
  2659.   }
  2660.   return isRequired;
  2661. }
  2662.  
  2663. /**
  2664.  * @function
  2665.  * @memberof Modifiers
  2666.  * @argument {Object} data - The data object generated by update method
  2667.  * @argument {Object} options - Modifiers configuration and options
  2668.  * @returns {Object} The data object, properly modified
  2669.  */
  2670. function arrow(data, options) {
  2671.   var _data$offsets$arrow;
  2672.  
  2673.   // arrow depends on keepTogether in order to work
  2674.   if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
  2675.     return data;
  2676.   }
  2677.  
  2678.   var arrowElement = options.element;
  2679.  
  2680.   // if arrowElement is a string, suppose it's a CSS selector
  2681.   if (typeof arrowElement === 'string') {
  2682.     arrowElement = data.instance.popper.querySelector(arrowElement);
  2683.  
  2684.     // if arrowElement is not found, don't run the modifier
  2685.     if (!arrowElement) {
  2686.       return data;
  2687.     }
  2688.   } else {
  2689.     // if the arrowElement isn't a query selector we must check that the
  2690.     // provided DOM node is child of its popper node
  2691.     if (!data.instance.popper.contains(arrowElement)) {
  2692.       console.warn('WARNING: `arrow.element` must be child of its popper element!');
  2693.       return data;
  2694.     }
  2695.   }
  2696.  
  2697.   var placement = data.placement.split('-')[0];
  2698.   var _data$offsets = data.offsets,
  2699.       popper = _data$offsets.popper,
  2700.       reference = _data$offsets.reference;
  2701.  
  2702.   var isVertical = ['left', 'right'].indexOf(placement) !== -1;
  2703.  
  2704.   var len = isVertical ? 'height' : 'width';
  2705.   var sideCapitalized = isVertical ? 'Top' : 'Left';
  2706.   var side = sideCapitalized.toLowerCase();
  2707.   var altSide = isVertical ? 'left' : 'top';
  2708.   var opSide = isVertical ? 'bottom' : 'right';
  2709.   var arrowElementSize = getOuterSizes(arrowElement)[len];
  2710.  
  2711.   //
  2712.   // extends keepTogether behavior making sure the popper and its
  2713.   // reference have enough pixels in conjuction
  2714.   //
  2715.  
  2716.   // top/left side
  2717.   if (reference[opSide] - arrowElementSize < popper[side]) {
  2718.     data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
  2719.   }
  2720.   // bottom/right side
  2721.   if (reference[side] + arrowElementSize > popper[opSide]) {
  2722.     data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
  2723.   }
  2724.   data.offsets.popper = getClientRect(data.offsets.popper);
  2725.  
  2726.   // compute center of the popper
  2727.   var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
  2728.  
  2729.   // Compute the sideValue using the updated popper offsets
  2730.   // take popper margin in account because we don't have this info available
  2731.   var css = getStyleComputedProperty(data.instance.popper);
  2732.   var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
  2733.   var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
  2734.   var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
  2735.  
  2736.   // prevent arrowElement from being placed not contiguously to its popper
  2737.   sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
  2738.  
  2739.   data.arrowElement = arrowElement;
  2740.   data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
  2741.  
  2742.   return data;
  2743. }
  2744.  
  2745. /**
  2746.  * Get the opposite placement variation of the given one
  2747.  * @method
  2748.  * @memberof Popper.Utils
  2749.  * @argument {String} placement variation
  2750.  * @returns {String} flipped placement variation
  2751.  */
  2752. function getOppositeVariation(variation) {
  2753.   if (variation === 'end') {
  2754.     return 'start';
  2755.   } else if (variation === 'start') {
  2756.     return 'end';
  2757.   }
  2758.   return variation;
  2759. }
  2760.  
  2761. /**
  2762.  * List of accepted placements to use as values of the `placement` option.<br />
  2763.  * Valid placements are:
  2764.  * - `auto`
  2765.  * - `top`
  2766.  * - `right`
  2767.  * - `bottom`
  2768.  * - `left`
  2769.  *
  2770.  * Each placement can have a variation from this list:
  2771.  * - `-start`
  2772.  * - `-end`
  2773.  *
  2774.  * Variations are interpreted easily if you think of them as the left to right
  2775.  * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
  2776.  * is right.<br />
  2777.  * Vertically (`left` and `right`), `start` is top and `end` is bottom.
  2778.  *
  2779.  * Some valid examples are:
  2780.  * - `top-end` (on top of reference, right aligned)
  2781.  * - `right-start` (on right of reference, top aligned)
  2782.  * - `bottom` (on bottom, centered)
  2783.  * - `auto-right` (on the side with more space available, alignment depends by placement)
  2784.  *
  2785.  * @static
  2786.  * @type {Array}
  2787.  * @enum {String}
  2788.  * @readonly
  2789.  * @method placements
  2790.  * @memberof Popper
  2791.  */
  2792. var 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'];
  2793.  
  2794. // Get rid of `auto` `auto-start` and `auto-end`
  2795. var validPlacements = placements.slice(3);
  2796.  
  2797. /**
  2798.  * Given an initial placement, returns all the subsequent placements
  2799.  * clockwise (or counter-clockwise).
  2800.  *
  2801.  * @method
  2802.  * @memberof Popper.Utils
  2803.  * @argument {String} placement - A valid placement (it accepts variations)
  2804.  * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
  2805.  * @returns {Array} placements including their variations
  2806.  */
  2807. function clockwise(placement) {
  2808.   var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  2809.  
  2810.   var index = validPlacements.indexOf(placement);
  2811.   var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
  2812.   return counter ? arr.reverse() : arr;
  2813. }
  2814.  
  2815. var BEHAVIORS = {
  2816.   FLIP: 'flip',
  2817.   CLOCKWISE: 'clockwise',
  2818.   COUNTERCLOCKWISE: 'counterclockwise'
  2819. };
  2820.  
  2821. /**
  2822.  * @function
  2823.  * @memberof Modifiers
  2824.  * @argument {Object} data - The data object generated by update method
  2825.  * @argument {Object} options - Modifiers configuration and options
  2826.  * @returns {Object} The data object, properly modified
  2827.  */
  2828. function flip(data, options) {
  2829.   // if `inner` modifier is enabled, we can't use the `flip` modifier
  2830.   if (isModifierEnabled(data.instance.modifiers, 'inner')) {
  2831.     return data;
  2832.   }
  2833.  
  2834.   if (data.flipped && data.placement === data.originalPlacement) {
  2835.     // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
  2836.     return data;
  2837.   }
  2838.  
  2839.   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement);
  2840.  
  2841.   var placement = data.placement.split('-')[0];
  2842.   var placementOpposite = getOppositePlacement(placement);
  2843.   var variation = data.placement.split('-')[1] || '';
  2844.  
  2845.   var flipOrder = [];
  2846.  
  2847.   switch (options.behavior) {
  2848.     case BEHAVIORS.FLIP:
  2849.       flipOrder = [placement, placementOpposite];
  2850.       break;
  2851.     case BEHAVIORS.CLOCKWISE:
  2852.       flipOrder = clockwise(placement);
  2853.       break;
  2854.     case BEHAVIORS.COUNTERCLOCKWISE:
  2855.       flipOrder = clockwise(placement, true);
  2856.       break;
  2857.     default:
  2858.       flipOrder = options.behavior;
  2859.   }
  2860.  
  2861.   flipOrder.forEach(function (step, index) {
  2862.     if (placement !== step || flipOrder.length === index + 1) {
  2863.       return data;
  2864.     }
  2865.  
  2866.     placement = data.placement.split('-')[0];
  2867.     placementOpposite = getOppositePlacement(placement);
  2868.  
  2869.     var popperOffsets = data.offsets.popper;
  2870.     var refOffsets = data.offsets.reference;
  2871.  
  2872.     // using floor because the reference offsets may contain decimals we are not going to consider here
  2873.     var floor = Math.floor;
  2874.     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);
  2875.  
  2876.     var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
  2877.     var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
  2878.     var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
  2879.     var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
  2880.  
  2881.     var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
  2882.  
  2883.     // flip the variation if required
  2884.     var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
  2885.     var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
  2886.  
  2887.     if (overlapsRef || overflowsBoundaries || flippedVariation) {
  2888.       // this boolean to detect any flip loop
  2889.       data.flipped = true;
  2890.  
  2891.       if (overlapsRef || overflowsBoundaries) {
  2892.         placement = flipOrder[index + 1];
  2893.       }
  2894.  
  2895.       if (flippedVariation) {
  2896.         variation = getOppositeVariation(variation);
  2897.       }
  2898.  
  2899.       data.placement = placement + (variation ? '-' + variation : '');
  2900.  
  2901.       // this object contains `position`, we want to preserve it along with
  2902.       // any additional property we may add in the future
  2903.       data.offsets.popper = _extends$1({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
  2904.  
  2905.       data = runModifiers(data.instance.modifiers, data, 'flip');
  2906.     }
  2907.   });
  2908.   return data;
  2909. }
  2910.  
  2911. /**
  2912.  * @function
  2913.  * @memberof Modifiers
  2914.  * @argument {Object} data - The data object generated by update method
  2915.  * @argument {Object} options - Modifiers configuration and options
  2916.  * @returns {Object} The data object, properly modified
  2917.  */
  2918. function keepTogether(data) {
  2919.   var _data$offsets = data.offsets,
  2920.       popper = _data$offsets.popper,
  2921.       reference = _data$offsets.reference;
  2922.  
  2923.   var placement = data.placement.split('-')[0];
  2924.   var floor = Math.floor;
  2925.   var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
  2926.   var side = isVertical ? 'right' : 'bottom';
  2927.   var opSide = isVertical ? 'left' : 'top';
  2928.   var measurement = isVertical ? 'width' : 'height';
  2929.  
  2930.   if (popper[side] < floor(reference[opSide])) {
  2931.     data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
  2932.   }
  2933.   if (popper[opSide] > floor(reference[side])) {
  2934.     data.offsets.popper[opSide] = floor(reference[side]);
  2935.   }
  2936.  
  2937.   return data;
  2938. }
  2939.  
  2940. /**
  2941.  * Converts a string containing value + unit into a px value number
  2942.  * @function
  2943.  * @memberof {modifiers~offset}
  2944.  * @private
  2945.  * @argument {String} str - Value + unit string
  2946.  * @argument {String} measurement - `height` or `width`
  2947.  * @argument {Object} popperOffsets
  2948.  * @argument {Object} referenceOffsets
  2949.  * @returns {Number|String}
  2950.  * Value in pixels, or original string if no values were extracted
  2951.  */
  2952. function toValue(str, measurement, popperOffsets, referenceOffsets) {
  2953.   // separate value from unit
  2954.   var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
  2955.   var value = +split[1];
  2956.   var unit = split[2];
  2957.  
  2958.   // If it's not a number it's an operator, I guess
  2959.   if (!value) {
  2960.     return str;
  2961.   }
  2962.  
  2963.   if (unit.indexOf('%') === 0) {
  2964.     var element = void 0;
  2965.     switch (unit) {
  2966.       case '%p':
  2967.         element = popperOffsets;
  2968.         break;
  2969.       case '%':
  2970.       case '%r':
  2971.       default:
  2972.         element = referenceOffsets;
  2973.     }
  2974.  
  2975.     var rect = getClientRect(element);
  2976.     return rect[measurement] / 100 * value;
  2977.   } else if (unit === 'vh' || unit === 'vw') {
  2978.     // if is a vh or vw, we calculate the size based on the viewport
  2979.     var size = void 0;
  2980.     if (unit === 'vh') {
  2981.       size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
  2982.     } else {
  2983.       size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
  2984.     }
  2985.     return size / 100 * value;
  2986.   } else {
  2987.     // if is an explicit pixel unit, we get rid of the unit and keep the value
  2988.     // if is an implicit unit, it's px, and we return just the value
  2989.     return value;
  2990.   }
  2991. }
  2992.  
  2993. /**
  2994.  * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
  2995.  * @function
  2996.  * @memberof {modifiers~offset}
  2997.  * @private
  2998.  * @argument {String} offset
  2999.  * @argument {Object} popperOffsets
  3000.  * @argument {Object} referenceOffsets
  3001.  * @argument {String} basePlacement
  3002.  * @returns {Array} a two cells array with x and y offsets in numbers
  3003.  */
  3004. function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
  3005.   var offsets = [0, 0];
  3006.  
  3007.   // Use height if placement is left or right and index is 0 otherwise use width
  3008.   // in this way the first offset will use an axis and the second one
  3009.   // will use the other one
  3010.   var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
  3011.  
  3012.   // Split the offset string to obtain a list of values and operands
  3013.   // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
  3014.   var fragments = offset.split(/(\+|\-)/).map(function (frag) {
  3015.     return frag.trim();
  3016.   });
  3017.  
  3018.   // Detect if the offset string contains a pair of values or a single one
  3019.   // they could be separated by comma or space
  3020.   var divider = fragments.indexOf(find(fragments, function (frag) {
  3021.     return frag.search(/,|\s/) !== -1;
  3022.   }));
  3023.  
  3024.   if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
  3025.     console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
  3026.   }
  3027.  
  3028.   // If divider is found, we divide the list of values and operands to divide
  3029.   // them by ofset X and Y.
  3030.   var splitRegex = /\s*,\s*|\s+/;
  3031.   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];
  3032.  
  3033.   // Convert the values with units to absolute pixels to allow our computations
  3034.   ops = ops.map(function (op, index) {
  3035.     // Most of the units rely on the orientation of the popper
  3036.     var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
  3037.     var mergeWithPrevious = false;
  3038.     return op
  3039.     // This aggregates any `+` or `-` sign that aren't considered operators
  3040.     // e.g.: 10 + +5 => [10, +, +5]
  3041.     .reduce(function (a, b) {
  3042.       if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
  3043.         a[a.length - 1] = b;
  3044.         mergeWithPrevious = true;
  3045.         return a;
  3046.       } else if (mergeWithPrevious) {
  3047.         a[a.length - 1] += b;
  3048.         mergeWithPrevious = false;
  3049.         return a;
  3050.       } else {
  3051.         return a.concat(b);
  3052.       }
  3053.     }, [])
  3054.     // Here we convert the string values into number values (in px)
  3055.     .map(function (str) {
  3056.       return toValue(str, measurement, popperOffsets, referenceOffsets);
  3057.     });
  3058.   });
  3059.  
  3060.   // Loop trough the offsets arrays and execute the operations
  3061.   ops.forEach(function (op, index) {
  3062.     op.forEach(function (frag, index2) {
  3063.       if (isNumeric(frag)) {
  3064.         offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
  3065.       }
  3066.     });
  3067.   });
  3068.   return offsets;
  3069. }
  3070.  
  3071. /**
  3072.  * @function
  3073.  * @memberof Modifiers
  3074.  * @argument {Object} data - The data object generated by update method
  3075.  * @argument {Object} options - Modifiers configuration and options
  3076.  * @argument {Number|String} options.offset=0
  3077.  * The offset value as described in the modifier description
  3078.  * @returns {Object} The data object, properly modified
  3079.  */
  3080. function offset(data, _ref) {
  3081.   var offset = _ref.offset;
  3082.   var placement = data.placement,
  3083.       _data$offsets = data.offsets,
  3084.       popper = _data$offsets.popper,
  3085.       reference = _data$offsets.reference;
  3086.  
  3087.   var basePlacement = placement.split('-')[0];
  3088.  
  3089.   var offsets = void 0;
  3090.   if (isNumeric(+offset)) {
  3091.     offsets = [+offset, 0];
  3092.   } else {
  3093.     offsets = parseOffset(offset, popper, reference, basePlacement);
  3094.   }
  3095.  
  3096.   if (basePlacement === 'left') {
  3097.     popper.top += offsets[0];
  3098.     popper.left -= offsets[1];
  3099.   } else if (basePlacement === 'right') {
  3100.     popper.top += offsets[0];
  3101.     popper.left += offsets[1];
  3102.   } else if (basePlacement === 'top') {
  3103.     popper.left += offsets[0];
  3104.     popper.top -= offsets[1];
  3105.   } else if (basePlacement === 'bottom') {
  3106.     popper.left += offsets[0];
  3107.     popper.top += offsets[1];
  3108.   }
  3109.  
  3110.   data.popper = popper;
  3111.   return data;
  3112. }
  3113.  
  3114. /**
  3115.  * @function
  3116.  * @memberof Modifiers
  3117.  * @argument {Object} data - The data object generated by `update` method
  3118.  * @argument {Object} options - Modifiers configuration and options
  3119.  * @returns {Object} The data object, properly modified
  3120.  */
  3121. function preventOverflow(data, options) {
  3122.   var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
  3123.  
  3124.   // If offsetParent is the reference element, we really want to
  3125.   // go one step up and use the next offsetParent as reference to
  3126.   // avoid to make this modifier completely useless and look like broken
  3127.   if (data.instance.reference === boundariesElement) {
  3128.     boundariesElement = getOffsetParent(boundariesElement);
  3129.   }
  3130.  
  3131.   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement);
  3132.   options.boundaries = boundaries;
  3133.  
  3134.   var order = options.priority;
  3135.   var popper = data.offsets.popper;
  3136.  
  3137.   var check = {
  3138.     primary: function primary(placement) {
  3139.       var value = popper[placement];
  3140.       if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
  3141.         value = Math.max(popper[placement], boundaries[placement]);
  3142.       }
  3143.       return defineProperty({}, placement, value);
  3144.     },
  3145.     secondary: function secondary(placement) {
  3146.       var mainSide = placement === 'right' ? 'left' : 'top';
  3147.       var value = popper[mainSide];
  3148.       if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
  3149.         value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
  3150.       }
  3151.       return defineProperty({}, mainSide, value);
  3152.     }
  3153.   };
  3154.  
  3155.   order.forEach(function (placement) {
  3156.     var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
  3157.     popper = _extends$1({}, popper, check[side](placement));
  3158.   });
  3159.  
  3160.   data.offsets.popper = popper;
  3161.  
  3162.   return data;
  3163. }
  3164.  
  3165. /**
  3166.  * @function
  3167.  * @memberof Modifiers
  3168.  * @argument {Object} data - The data object generated by `update` method
  3169.  * @argument {Object} options - Modifiers configuration and options
  3170.  * @returns {Object} The data object, properly modified
  3171.  */
  3172. function shift(data) {
  3173.   var placement = data.placement;
  3174.   var basePlacement = placement.split('-')[0];
  3175.   var shiftvariation = placement.split('-')[1];
  3176.  
  3177.   // if shift shiftvariation is specified, run the modifier
  3178.   if (shiftvariation) {
  3179.     var _data$offsets = data.offsets,
  3180.         reference = _data$offsets.reference,
  3181.         popper = _data$offsets.popper;
  3182.  
  3183.     var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
  3184.     var side = isVertical ? 'left' : 'top';
  3185.     var measurement = isVertical ? 'width' : 'height';
  3186.  
  3187.     var shiftOffsets = {
  3188.       start: defineProperty({}, side, reference[side]),
  3189.       end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
  3190.     };
  3191.  
  3192.     data.offsets.popper = _extends$1({}, popper, shiftOffsets[shiftvariation]);
  3193.   }
  3194.  
  3195.   return data;
  3196. }
  3197.  
  3198. /**
  3199.  * @function
  3200.  * @memberof Modifiers
  3201.  * @argument {Object} data - The data object generated by update method
  3202.  * @argument {Object} options - Modifiers configuration and options
  3203.  * @returns {Object} The data object, properly modified
  3204.  */
  3205. function hide(data) {
  3206.   if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
  3207.     return data;
  3208.   }
  3209.  
  3210.   var refRect = data.offsets.reference;
  3211.   var bound = find(data.instance.modifiers, function (modifier) {
  3212.     return modifier.name === 'preventOverflow';
  3213.   }).boundaries;
  3214.  
  3215.   if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
  3216.     // Avoid unnecessary DOM access if visibility hasn't changed
  3217.     if (data.hide === true) {
  3218.       return data;
  3219.     }
  3220.  
  3221.     data.hide = true;
  3222.     data.attributes['x-out-of-boundaries'] = '';
  3223.   } else {
  3224.     // Avoid unnecessary DOM access if visibility hasn't changed
  3225.     if (data.hide === false) {
  3226.       return data;
  3227.     }
  3228.  
  3229.     data.hide = false;
  3230.     data.attributes['x-out-of-boundaries'] = false;
  3231.   }
  3232.  
  3233.   return data;
  3234. }
  3235.  
  3236. /**
  3237.  * @function
  3238.  * @memberof Modifiers
  3239.  * @argument {Object} data - The data object generated by `update` method
  3240.  * @argument {Object} options - Modifiers configuration and options
  3241.  * @returns {Object} The data object, properly modified
  3242.  */
  3243. function inner(data) {
  3244.   var placement = data.placement;
  3245.   var basePlacement = placement.split('-')[0];
  3246.   var _data$offsets = data.offsets,
  3247.       popper = _data$offsets.popper,
  3248.       reference = _data$offsets.reference;
  3249.  
  3250.   var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
  3251.  
  3252.   var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
  3253.  
  3254.   popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
  3255.  
  3256.   data.placement = getOppositePlacement(placement);
  3257.   data.offsets.popper = getClientRect(popper);
  3258.  
  3259.   return data;
  3260. }
  3261.  
  3262. /**
  3263.  * Modifier function, each modifier can have a function of this type assigned
  3264.  * to its `fn` property.<br />
  3265.  * These functions will be called on each update, this means that you must
  3266.  * make sure they are performant enough to avoid performance bottlenecks.
  3267.  *
  3268.  * @function ModifierFn
  3269.  * @argument {dataObject} data - The data object generated by `update` method
  3270.  * @argument {Object} options - Modifiers configuration and options
  3271.  * @returns {dataObject} The data object, properly modified
  3272.  */
  3273.  
  3274. /**
  3275.  * Modifiers are plugins used to alter the behavior of your poppers.<br />
  3276.  * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
  3277.  * needed by the library.
  3278.  *
  3279.  * Usually you don't want to override the `order`, `fn` and `onLoad` props.
  3280.  * All the other properties are configurations that could be tweaked.
  3281.  * @namespace modifiers
  3282.  */
  3283. var modifiers = {
  3284.   /**
  3285.    * Modifier used to shift the popper on the start or end of its reference
  3286.    * element.<br />
  3287.    * It will read the variation of the `placement` property.<br />
  3288.    * It can be one either `-end` or `-start`.
  3289.    * @memberof modifiers
  3290.    * @inner
  3291.    */
  3292.   shift: {
  3293.     /** @prop {number} order=100 - Index used to define the order of execution */
  3294.     order: 100,
  3295.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3296.     enabled: true,
  3297.     /** @prop {ModifierFn} */
  3298.     fn: shift
  3299.   },
  3300.  
  3301.   /**
  3302.    * The `offset` modifier can shift your popper on both its axis.
  3303.    *
  3304.    * It accepts the following units:
  3305.    * - `px` or unitless, interpreted as pixels
  3306.    * - `%` or `%r`, percentage relative to the length of the reference element
  3307.    * - `%p`, percentage relative to the length of the popper element
  3308.    * - `vw`, CSS viewport width unit
  3309.    * - `vh`, CSS viewport height unit
  3310.    *
  3311.    * For length is intended the main axis relative to the placement of the popper.<br />
  3312.    * This means that if the placement is `top` or `bottom`, the length will be the
  3313.    * `width`. In case of `left` or `right`, it will be the height.
  3314.    *
  3315.    * You can provide a single value (as `Number` or `String`), or a pair of values
  3316.    * as `String` divided by a comma or one (or more) white spaces.<br />
  3317.    * The latter is a deprecated method because it leads to confusion and will be
  3318.    * removed in v2.<br />
  3319.    * Additionally, it accepts additions and subtractions between different units.
  3320.    * Note that multiplications and divisions aren't supported.
  3321.    *
  3322.    * Valid examples are:
  3323.    * ```
  3324.    * 10
  3325.    * '10%'
  3326.    * '10, 10'
  3327.    * '10%, 10'
  3328.    * '10 + 10%'
  3329.    * '10 - 5vh + 3%'
  3330.    * '-10px + 5vh, 5px - 6%'
  3331.    * ```
  3332.    * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
  3333.    * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
  3334.    * > More on this [reading this issue](https://github.com/FezVrasta/popper.js/issues/373)
  3335.    *
  3336.    * @memberof modifiers
  3337.    * @inner
  3338.    */
  3339.   offset: {
  3340.     /** @prop {number} order=200 - Index used to define the order of execution */
  3341.     order: 200,
  3342.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3343.     enabled: true,
  3344.     /** @prop {ModifierFn} */
  3345.     fn: offset,
  3346.     /** @prop {Number|String} offset=0
  3347.      * The offset value as described in the modifier description
  3348.      */
  3349.     offset: 0
  3350.   },
  3351.  
  3352.   /**
  3353.    * Modifier used to prevent the popper from being positioned outside the boundary.
  3354.    *
  3355.    * An scenario exists where the reference itself is not within the boundaries.<br />
  3356.    * We can say it has "escaped the boundaries" — or just "escaped".<br />
  3357.    * In this case we need to decide whether the popper should either:
  3358.    *
  3359.    * - detach from the reference and remain "trapped" in the boundaries, or
  3360.    * - if it should ignore the boundary and "escape with its reference"
  3361.    *
  3362.    * When `escapeWithReference` is set to`true` and reference is completely
  3363.    * outside its boundaries, the popper will overflow (or completely leave)
  3364.    * the boundaries in order to remain attached to the edge of the reference.
  3365.    *
  3366.    * @memberof modifiers
  3367.    * @inner
  3368.    */
  3369.   preventOverflow: {
  3370.     /** @prop {number} order=300 - Index used to define the order of execution */
  3371.     order: 300,
  3372.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3373.     enabled: true,
  3374.     /** @prop {ModifierFn} */
  3375.     fn: preventOverflow,
  3376.     /**
  3377.      * @prop {Array} [priority=['left','right','top','bottom']]
  3378.      * Popper will try to prevent overflow following these priorities by default,
  3379.      * then, it could overflow on the left and on top of the `boundariesElement`
  3380.      */
  3381.     priority: ['left', 'right', 'top', 'bottom'],
  3382.     /**
  3383.      * @prop {number} padding=5
  3384.      * Amount of pixel used to define a minimum distance between the boundaries
  3385.      * and the popper this makes sure the popper has always a little padding
  3386.      * between the edges of its container
  3387.      */
  3388.     padding: 5,
  3389.     /**
  3390.      * @prop {String|HTMLElement} boundariesElement='scrollParent'
  3391.      * Boundaries used by the modifier, can be `scrollParent`, `window`,
  3392.      * `viewport` or any DOM element.
  3393.      */
  3394.     boundariesElement: 'scrollParent'
  3395.   },
  3396.  
  3397.   /**
  3398.    * Modifier used to make sure the reference and its popper stay near eachothers
  3399.    * without leaving any gap between the two. Expecially useful when the arrow is
  3400.    * enabled and you want to assure it to point to its reference element.
  3401.    * It cares only about the first axis, you can still have poppers with margin
  3402.    * between the popper and its reference element.
  3403.    * @memberof modifiers
  3404.    * @inner
  3405.    */
  3406.   keepTogether: {
  3407.     /** @prop {number} order=400 - Index used to define the order of execution */
  3408.     order: 400,
  3409.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3410.     enabled: true,
  3411.     /** @prop {ModifierFn} */
  3412.     fn: keepTogether
  3413.   },
  3414.  
  3415.   /**
  3416.    * This modifier is used to move the `arrowElement` of the popper to make
  3417.    * sure it is positioned between the reference element and its popper element.
  3418.    * It will read the outer size of the `arrowElement` node to detect how many
  3419.    * pixels of conjuction are needed.
  3420.    *
  3421.    * It has no effect if no `arrowElement` is provided.
  3422.    * @memberof modifiers
  3423.    * @inner
  3424.    */
  3425.   arrow: {
  3426.     /** @prop {number} order=500 - Index used to define the order of execution */
  3427.     order: 500,
  3428.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3429.     enabled: true,
  3430.     /** @prop {ModifierFn} */
  3431.     fn: arrow,
  3432.     /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
  3433.     element: '[x-arrow]'
  3434.   },
  3435.  
  3436.   /**
  3437.    * Modifier used to flip the popper's placement when it starts to overlap its
  3438.    * reference element.
  3439.    *
  3440.    * Requires the `preventOverflow` modifier before it in order to work.
  3441.    *
  3442.    * **NOTE:** this modifier will interrupt the current update cycle and will
  3443.    * restart it if it detects the need to flip the placement.
  3444.    * @memberof modifiers
  3445.    * @inner
  3446.    */
  3447.   flip: {
  3448.     /** @prop {number} order=600 - Index used to define the order of execution */
  3449.     order: 600,
  3450.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3451.     enabled: true,
  3452.     /** @prop {ModifierFn} */
  3453.     fn: flip,
  3454.     /**
  3455.      * @prop {String|Array} behavior='flip'
  3456.      * The behavior used to change the popper's placement. It can be one of
  3457.      * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
  3458.      * placements (with optional variations).
  3459.      */
  3460.     behavior: 'flip',
  3461.     /**
  3462.      * @prop {number} padding=5
  3463.      * The popper will flip if it hits the edges of the `boundariesElement`
  3464.      */
  3465.     padding: 5,
  3466.     /**
  3467.      * @prop {String|HTMLElement} boundariesElement='viewport'
  3468.      * The element which will define the boundaries of the popper position,
  3469.      * the popper will never be placed outside of the defined boundaries
  3470.      * (except if keepTogether is enabled)
  3471.      */
  3472.     boundariesElement: 'viewport'
  3473.   },
  3474.  
  3475.   /**
  3476.    * Modifier used to make the popper flow toward the inner of the reference element.
  3477.    * By default, when this modifier is disabled, the popper will be placed outside
  3478.    * the reference element.
  3479.    * @memberof modifiers
  3480.    * @inner
  3481.    */
  3482.   inner: {
  3483.     /** @prop {number} order=700 - Index used to define the order of execution */
  3484.     order: 700,
  3485.     /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
  3486.     enabled: false,
  3487.     /** @prop {ModifierFn} */
  3488.     fn: inner
  3489.   },
  3490.  
  3491.   /**
  3492.    * Modifier used to hide the popper when its reference element is outside of the
  3493.    * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
  3494.    * be used to hide with a CSS selector the popper when its reference is
  3495.    * out of boundaries.
  3496.    *
  3497.    * Requires the `preventOverflow` modifier before it in order to work.
  3498.    * @memberof modifiers
  3499.    * @inner
  3500.    */
  3501.   hide: {
  3502.     /** @prop {number} order=800 - Index used to define the order of execution */
  3503.     order: 800,
  3504.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3505.     enabled: true,
  3506.     /** @prop {ModifierFn} */
  3507.     fn: hide
  3508.   },
  3509.  
  3510.   /**
  3511.    * Computes the style that will be applied to the popper element to gets
  3512.    * properly positioned.
  3513.    *
  3514.    * Note that this modifier will not touch the DOM, it just prepares the styles
  3515.    * so that `applyStyle` modifier can apply it. This separation is useful
  3516.    * in case you need to replace `applyStyle` with a custom implementation.
  3517.    *
  3518.    * This modifier has `850` as `order` value to maintain backward compatibility
  3519.    * with previous versions of Popper.js. Expect the modifiers ordering method
  3520.    * to change in future major versions of the library.
  3521.    *
  3522.    * @memberof modifiers
  3523.    * @inner
  3524.    */
  3525.   computeStyle: {
  3526.     /** @prop {number} order=850 - Index used to define the order of execution */
  3527.     order: 850,
  3528.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3529.     enabled: true,
  3530.     /** @prop {ModifierFn} */
  3531.     fn: computeStyle,
  3532.     /**
  3533.      * @prop {Boolean} gpuAcceleration=true
  3534.      * If true, it uses the CSS 3d transformation to position the popper.
  3535.      * Otherwise, it will use the `top` and `left` properties.
  3536.      */
  3537.     gpuAcceleration: true,
  3538.     /**
  3539.      * @prop {string} [x='bottom']
  3540.      * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
  3541.      * Change this if your popper should grow in a direction different from `bottom`
  3542.      */
  3543.     x: 'bottom',
  3544.     /**
  3545.      * @prop {string} [x='left']
  3546.      * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
  3547.      * Change this if your popper should grow in a direction different from `right`
  3548.      */
  3549.     y: 'right'
  3550.   },
  3551.  
  3552.   /**
  3553.    * Applies the computed styles to the popper element.
  3554.    *
  3555.    * All the DOM manipulations are limited to this modifier. This is useful in case
  3556.    * you want to integrate Popper.js inside a framework or view library and you
  3557.    * want to delegate all the DOM manipulations to it.
  3558.    *
  3559.    * Note that if you disable this modifier, you must make sure the popper element
  3560.    * has its position set to `absolute` before Popper.js can do its work!
  3561.    *
  3562.    * Just disable this modifier and define you own to achieve the desired effect.
  3563.    *
  3564.    * @memberof modifiers
  3565.    * @inner
  3566.    */
  3567.   applyStyle: {
  3568.     /** @prop {number} order=900 - Index used to define the order of execution */
  3569.     order: 900,
  3570.     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
  3571.     enabled: true,
  3572.     /** @prop {ModifierFn} */
  3573.     fn: applyStyle,
  3574.     /** @prop {Function} */
  3575.     onLoad: applyStyleOnLoad,
  3576.     /**
  3577.      * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
  3578.      * @prop {Boolean} gpuAcceleration=true
  3579.      * If true, it uses the CSS 3d transformation to position the popper.
  3580.      * Otherwise, it will use the `top` and `left` properties.
  3581.      */
  3582.     gpuAcceleration: undefined
  3583.   }
  3584. };
  3585.  
  3586. /**
  3587.  * The `dataObject` is an object containing all the informations used by Popper.js
  3588.  * this object get passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
  3589.  * @name dataObject
  3590.  * @property {Object} data.instance The Popper.js instance
  3591.  * @property {String} data.placement Placement applied to popper
  3592.  * @property {String} data.originalPlacement Placement originally defined on init
  3593.  * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
  3594.  * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper.
  3595.  * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
  3596.  * @property {Object} data.styles Any CSS property defined here will be applied to the popper, it expects the JavaScript nomenclature (eg. `marginBottom`)
  3597.  * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow, it expects the JavaScript nomenclature (eg. `marginBottom`)
  3598.  * @property {Object} data.boundaries Offsets of the popper boundaries
  3599.  * @property {Object} data.offsets The measurements of popper, reference and arrow elements.
  3600.  * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
  3601.  * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
  3602.  * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
  3603.  */
  3604.  
  3605. /**
  3606.  * Default options provided to Popper.js constructor.<br />
  3607.  * These can be overriden using the `options` argument of Popper.js.<br />
  3608.  * To override an option, simply pass as 3rd argument an object with the same
  3609.  * structure of this object, example:
  3610.  * ```
  3611.  * new Popper(ref, pop, {
  3612.  *   modifiers: {
  3613.  *     preventOverflow: { enabled: false }
  3614.  *   }
  3615.  * })
  3616.  * ```
  3617.  * @type {Object}
  3618.  * @static
  3619.  * @memberof Popper
  3620.  */
  3621. var Defaults = {
  3622.   /**
  3623.    * Popper's placement
  3624.    * @prop {Popper.placements} placement='bottom'
  3625.    */
  3626.   placement: 'bottom',
  3627.  
  3628.   /**
  3629.    * Whether events (resize, scroll) are initially enabled
  3630.    * @prop {Boolean} eventsEnabled=true
  3631.    */
  3632.   eventsEnabled: true,
  3633.  
  3634.   /**
  3635.    * Set to true if you want to automatically remove the popper when
  3636.    * you call the `destroy` method.
  3637.    * @prop {Boolean} removeOnDestroy=false
  3638.    */
  3639.   removeOnDestroy: false,
  3640.  
  3641.   /**
  3642.    * Callback called when the popper is created.<br />
  3643.    * By default, is set to no-op.<br />
  3644.    * Access Popper.js instance with `data.instance`.
  3645.    * @prop {onCreate}
  3646.    */
  3647.   onCreate: function onCreate() {},
  3648.  
  3649.   /**
  3650.    * Callback called when the popper is updated, this callback is not called
  3651.    * on the initialization/creation of the popper, but only on subsequent
  3652.    * updates.<br />
  3653.    * By default, is set to no-op.<br />
  3654.    * Access Popper.js instance with `data.instance`.
  3655.    * @prop {onUpdate}
  3656.    */
  3657.   onUpdate: function onUpdate() {},
  3658.  
  3659.   /**
  3660.    * List of modifiers used to modify the offsets before they are applied to the popper.
  3661.    * They provide most of the functionalities of Popper.js
  3662.    * @prop {modifiers}
  3663.    */
  3664.   modifiers: modifiers
  3665. };
  3666.  
  3667. /**
  3668.  * @callback onCreate
  3669.  * @param {dataObject} data
  3670.  */
  3671.  
  3672. /**
  3673.  * @callback onUpdate
  3674.  * @param {dataObject} data
  3675.  */
  3676.  
  3677. // Utils
  3678. // Methods
  3679. var Popper = function () {
  3680.   /**
  3681.    * Create a new Popper.js instance
  3682.    * @class Popper
  3683.    * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper
  3684.    * @param {HTMLElement} popper - The HTML element used as popper.
  3685.    * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
  3686.    * @return {Object} instance - The generated Popper.js instance
  3687.    */
  3688.   function Popper(reference, popper) {
  3689.     var _this = this;
  3690.  
  3691.     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  3692.     classCallCheck(this, Popper);
  3693.  
  3694.     this.scheduleUpdate = function () {
  3695.       return requestAnimationFrame(_this.update);
  3696.     };
  3697.  
  3698.     // make update() debounced, so that it only runs at most once-per-tick
  3699.     this.update = debounce(this.update.bind(this));
  3700.  
  3701.     // with {} we create a new object with the options inside it
  3702.     this.options = _extends$1({}, Popper.Defaults, options);
  3703.  
  3704.     // init state
  3705.     this.state = {
  3706.       isDestroyed: false,
  3707.       isCreated: false,
  3708.       scrollParents: []
  3709.     };
  3710.  
  3711.     // get reference and popper elements (allow jQuery wrappers)
  3712.     this.reference = reference && reference.jquery ? reference[0] : reference;
  3713.     this.popper = popper && popper.jquery ? popper[0] : popper;
  3714.  
  3715.     // Deep merge modifiers options
  3716.     this.options.modifiers = {};
  3717.     Object.keys(_extends$1({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
  3718.       _this.options.modifiers[name] = _extends$1({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
  3719.     });
  3720.  
  3721.     // Refactoring modifiers' list (Object => Array)
  3722.     this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
  3723.       return _extends$1({
  3724.         name: name
  3725.       }, _this.options.modifiers[name]);
  3726.     })
  3727.     // sort the modifiers by order
  3728.     .sort(function (a, b) {
  3729.       return a.order - b.order;
  3730.     });
  3731.  
  3732.     // modifiers have the ability to execute arbitrary code when Popper.js get inited
  3733.     // such code is executed in the same order of its modifier
  3734.     // they could add new properties to their options configuration
  3735.     // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
  3736.     this.modifiers.forEach(function (modifierOptions) {
  3737.       if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
  3738.         modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
  3739.       }
  3740.     });
  3741.  
  3742.     // fire the first update to position the popper in the right place
  3743.     this.update();
  3744.  
  3745.     var eventsEnabled = this.options.eventsEnabled;
  3746.     if (eventsEnabled) {
  3747.       // setup event listeners, they will take care of update the position in specific situations
  3748.       this.enableEventListeners();
  3749.     }
  3750.  
  3751.     this.state.eventsEnabled = eventsEnabled;
  3752.   }
  3753.  
  3754.   // We can't use class properties because they don't get listed in the
  3755.   // class prototype and break stuff like Sinon stubs
  3756.  
  3757.  
  3758.   createClass(Popper, [{
  3759.     key: 'update',
  3760.     value: function update$$1() {
  3761.       return update.call(this);
  3762.     }
  3763.   }, {
  3764.     key: 'destroy',
  3765.     value: function destroy$$1() {
  3766.       return destroy.call(this);
  3767.     }
  3768.   }, {
  3769.     key: 'enableEventListeners',
  3770.     value: function enableEventListeners$$1() {
  3771.       return enableEventListeners.call(this);
  3772.     }
  3773.   }, {
  3774.     key: 'disableEventListeners',
  3775.     value: function disableEventListeners$$1() {
  3776.       return disableEventListeners.call(this);
  3777.     }
  3778.  
  3779.     /**
  3780.      * Schedule an update, it will run on the next UI update available
  3781.      * @method scheduleUpdate
  3782.      * @memberof Popper
  3783.      */
  3784.  
  3785.  
  3786.     /**
  3787.      * Collection of utilities useful when writing custom modifiers.
  3788.      * Starting from version 1.7, this method is available only if you
  3789.      * include `popper-utils.js` before `popper.js`.
  3790.      *
  3791.      * **DEPRECATION**: This way to access PopperUtils is deprecated
  3792.      * and will be removed in v2! Use the PopperUtils module directly instead.
  3793.      * Due to the high instability of the methods contained in Utils, we can't
  3794.      * guarantee them to follow semver. Use them at your own risk!
  3795.      * @static
  3796.      * @private
  3797.      * @type {Object}
  3798.      * @deprecated since version 1.8
  3799.      * @member Utils
  3800.      * @memberof Popper
  3801.      */
  3802.  
  3803.   }]);
  3804.   return Popper;
  3805. }();
  3806.  
  3807. /**
  3808.  * The `referenceObject` is an object that provides an interface compatible with Popper.js
  3809.  * and lets you use it as replacement of a real DOM node.<br />
  3810.  * You can use this method to position a popper relatively to a set of coordinates
  3811.  * in case you don't have a DOM node to use as reference.
  3812.  *
  3813.  * ```
  3814.  * new Popper(referenceObject, popperNode);
  3815.  * ```
  3816.  *
  3817.  * NB: This feature isn't supported in Internet Explorer 10
  3818.  * @name referenceObject
  3819.  * @property {Function} data.getBoundingClientRect
  3820.  * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
  3821.  * @property {number} data.clientWidth
  3822.  * An ES6 getter that will return the width of the virtual reference element.
  3823.  * @property {number} data.clientHeight
  3824.  * An ES6 getter that will return the height of the virtual reference element.
  3825.  */
  3826.  
  3827.  
  3828. Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
  3829. Popper.placements = placements;
  3830. Popper.Defaults = Defaults;
  3831.  
  3832. /**
  3833.  * --------------------------------------------------------------------------
  3834.  * Bootstrap (v4.0.0): dropdown.js
  3835.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  3836.  * --------------------------------------------------------------------------
  3837.  */
  3838.  
  3839. var Dropdown = function ($$$1) {
  3840.   /**
  3841.    * ------------------------------------------------------------------------
  3842.    * Constants
  3843.    * ------------------------------------------------------------------------
  3844.    */
  3845.   var NAME = 'dropdown';
  3846.   var VERSION = '4.0.0';
  3847.   var DATA_KEY = 'bs.dropdown';
  3848.   var EVENT_KEY = "." + DATA_KEY;
  3849.   var DATA_API_KEY = '.data-api';
  3850.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  3851.   var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
  3852.  
  3853.   var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
  3854.  
  3855.   var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
  3856.  
  3857.   var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
  3858.  
  3859.   var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
  3860.  
  3861.   var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
  3862.  
  3863.   var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
  3864.   var Event = {
  3865.     HIDE: "hide" + EVENT_KEY,
  3866.     HIDDEN: "hidden" + EVENT_KEY,
  3867.     SHOW: "show" + EVENT_KEY,
  3868.     SHOWN: "shown" + EVENT_KEY,
  3869.     CLICK: "click" + EVENT_KEY,
  3870.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
  3871.     KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
  3872.     KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY
  3873.   };
  3874.   var ClassName = {
  3875.     DISABLED: 'disabled',
  3876.     SHOW: 'show',
  3877.     DROPUP: 'dropup',
  3878.     DROPRIGHT: 'dropright',
  3879.     DROPLEFT: 'dropleft',
  3880.     MENURIGHT: 'dropdown-menu-right',
  3881.     MENULEFT: 'dropdown-menu-left',
  3882.     POSITION_STATIC: 'position-static'
  3883.   };
  3884.   var Selector = {
  3885.     DATA_TOGGLE: '[data-toggle="dropdown"]',
  3886.     FORM_CHILD: '.dropdown form',
  3887.     MENU: '.dropdown-menu',
  3888.     NAVBAR_NAV: '.navbar-nav',
  3889.     VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled)'
  3890.   };
  3891.   var AttachmentMap = {
  3892.     TOP: 'top-start',
  3893.     TOPEND: 'top-end',
  3894.     BOTTOM: 'bottom-start',
  3895.     BOTTOMEND: 'bottom-end',
  3896.     RIGHT: 'right-start',
  3897.     RIGHTEND: 'right-end',
  3898.     LEFT: 'left-start',
  3899.     LEFTEND: 'left-end'
  3900.   };
  3901.   var Default = {
  3902.     offset: 0,
  3903.     flip: true,
  3904.     boundary: 'scrollParent'
  3905.   };
  3906.   var DefaultType = {
  3907.     offset: '(number|string|function)',
  3908.     flip: 'boolean',
  3909.     boundary: '(string|element)'
  3910.     /**
  3911.      * ------------------------------------------------------------------------
  3912.      * Class Definition
  3913.      * ------------------------------------------------------------------------
  3914.      */
  3915.  
  3916.   };
  3917.  
  3918.   var Dropdown =
  3919.   /*#__PURE__*/
  3920.   function () {
  3921.     function Dropdown(element, config) {
  3922.       this._element = element;
  3923.       this._popper = null;
  3924.       this._config = this._getConfig(config);
  3925.       this._menu = this._getMenuElement();
  3926.       this._inNavbar = this._detectNavbar();
  3927.  
  3928.       this._addEventListeners();
  3929.     } // Getters
  3930.  
  3931.  
  3932.     var _proto = Dropdown.prototype;
  3933.  
  3934.     // Public
  3935.     _proto.toggle = function toggle() {
  3936.       if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
  3937.         return;
  3938.       }
  3939.  
  3940.       var parent = Dropdown._getParentFromElement(this._element);
  3941.  
  3942.       var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
  3943.  
  3944.       Dropdown._clearMenus();
  3945.  
  3946.       if (isActive) {
  3947.         return;
  3948.       }
  3949.  
  3950.       var relatedTarget = {
  3951.         relatedTarget: this._element
  3952.       };
  3953.       var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
  3954.       $$$1(parent).trigger(showEvent);
  3955.  
  3956.       if (showEvent.isDefaultPrevented()) {
  3957.         return;
  3958.       } // Disable totally Popper.js for Dropdown in Navbar
  3959.  
  3960.  
  3961.       if (!this._inNavbar) {
  3962.         /**
  3963.          * Check for Popper dependency
  3964.          * Popper - https://popper.js.org
  3965.          */
  3966.         if (typeof Popper === 'undefined') {
  3967.           throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
  3968.         }
  3969.  
  3970.         var element = this._element; // For dropup with alignment we use the parent as popper container
  3971.  
  3972.         if ($$$1(parent).hasClass(ClassName.DROPUP)) {
  3973.           if ($$$1(this._menu).hasClass(ClassName.MENULEFT) || $$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
  3974.             element = parent;
  3975.           }
  3976.         } // If boundary is not `scrollParent`, then set position to `static`
  3977.         // to allow the menu to "escape" the scroll parent's boundaries
  3978.         // https://github.com/twbs/bootstrap/issues/24251
  3979.  
  3980.  
  3981.         if (this._config.boundary !== 'scrollParent') {
  3982.           $$$1(parent).addClass(ClassName.POSITION_STATIC);
  3983.         }
  3984.  
  3985.         this._popper = new Popper(element, this._menu, this._getPopperConfig());
  3986.       } // If this is a touch-enabled device we add extra
  3987.       // empty mouseover listeners to the body's immediate children;
  3988.       // only needed because of broken event delegation on iOS
  3989.       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
  3990.  
  3991.  
  3992.       if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
  3993.         $$$1('body').children().on('mouseover', null, $$$1.noop);
  3994.       }
  3995.  
  3996.       this._element.focus();
  3997.  
  3998.       this._element.setAttribute('aria-expanded', true);
  3999.  
  4000.       $$$1(this._menu).toggleClass(ClassName.SHOW);
  4001.       $$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
  4002.     };
  4003.  
  4004.     _proto.dispose = function dispose() {
  4005.       $$$1.removeData(this._element, DATA_KEY);
  4006.       $$$1(this._element).off(EVENT_KEY);
  4007.       this._element = null;
  4008.       this._menu = null;
  4009.  
  4010.       if (this._popper !== null) {
  4011.         this._popper.destroy();
  4012.  
  4013.         this._popper = null;
  4014.       }
  4015.     };
  4016.  
  4017.     _proto.update = function update() {
  4018.       this._inNavbar = this._detectNavbar();
  4019.  
  4020.       if (this._popper !== null) {
  4021.         this._popper.scheduleUpdate();
  4022.       }
  4023.     }; // Private
  4024.  
  4025.  
  4026.     _proto._addEventListeners = function _addEventListeners() {
  4027.       var _this = this;
  4028.  
  4029.       $$$1(this._element).on(Event.CLICK, function (event) {
  4030.         event.preventDefault();
  4031.         event.stopPropagation();
  4032.  
  4033.         _this.toggle();
  4034.       });
  4035.     };
  4036.  
  4037.     _proto._getConfig = function _getConfig(config) {
  4038.       config = _extends({}, this.constructor.Default, $$$1(this._element).data(), config);
  4039.       Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
  4040.       return config;
  4041.     };
  4042.  
  4043.     _proto._getMenuElement = function _getMenuElement() {
  4044.       if (!this._menu) {
  4045.         var parent = Dropdown._getParentFromElement(this._element);
  4046.  
  4047.         this._menu = $$$1(parent).find(Selector.MENU)[0];
  4048.       }
  4049.  
  4050.       return this._menu;
  4051.     };
  4052.  
  4053.     _proto._getPlacement = function _getPlacement() {
  4054.       var $parentDropdown = $$$1(this._element).parent();
  4055.       var placement = AttachmentMap.BOTTOM; // Handle dropup
  4056.  
  4057.       if ($parentDropdown.hasClass(ClassName.DROPUP)) {
  4058.         placement = AttachmentMap.TOP;
  4059.  
  4060.         if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
  4061.           placement = AttachmentMap.TOPEND;
  4062.         }
  4063.       } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
  4064.         placement = AttachmentMap.RIGHT;
  4065.       } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
  4066.         placement = AttachmentMap.LEFT;
  4067.       } else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
  4068.         placement = AttachmentMap.BOTTOMEND;
  4069.       }
  4070.  
  4071.       return placement;
  4072.     };
  4073.  
  4074.     _proto._detectNavbar = function _detectNavbar() {
  4075.       return $$$1(this._element).closest('.navbar').length > 0;
  4076.     };
  4077.  
  4078.     _proto._getPopperConfig = function _getPopperConfig() {
  4079.       var _this2 = this;
  4080.  
  4081.       var offsetConf = {};
  4082.  
  4083.       if (typeof this._config.offset === 'function') {
  4084.         offsetConf.fn = function (data) {
  4085.           data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets) || {});
  4086.           return data;
  4087.         };
  4088.       } else {
  4089.         offsetConf.offset = this._config.offset;
  4090.       }
  4091.  
  4092.       var popperConfig = {
  4093.         placement: this._getPlacement(),
  4094.         modifiers: {
  4095.           offset: offsetConf,
  4096.           flip: {
  4097.             enabled: this._config.flip
  4098.           },
  4099.           preventOverflow: {
  4100.             boundariesElement: this._config.boundary
  4101.           }
  4102.         }
  4103.       };
  4104.       return popperConfig;
  4105.     }; // Static
  4106.  
  4107.  
  4108.     Dropdown._jQueryInterface = function _jQueryInterface(config) {
  4109.       return this.each(function () {
  4110.         var data = $$$1(this).data(DATA_KEY);
  4111.  
  4112.         var _config = typeof config === 'object' ? config : null;
  4113.  
  4114.         if (!data) {
  4115.           data = new Dropdown(this, _config);
  4116.           $$$1(this).data(DATA_KEY, data);
  4117.         }
  4118.  
  4119.         if (typeof config === 'string') {
  4120.           if (typeof data[config] === 'undefined') {
  4121.             throw new TypeError("No method named \"" + config + "\"");
  4122.           }
  4123.  
  4124.           data[config]();
  4125.         }
  4126.       });
  4127.     };
  4128.  
  4129.     Dropdown._clearMenus = function _clearMenus(event) {
  4130.       if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
  4131.         return;
  4132.       }
  4133.  
  4134.       var toggles = $$$1.makeArray($$$1(Selector.DATA_TOGGLE));
  4135.  
  4136.       for (var i = 0; i < toggles.length; i++) {
  4137.         var parent = Dropdown._getParentFromElement(toggles[i]);
  4138.  
  4139.         var context = $$$1(toggles[i]).data(DATA_KEY);
  4140.         var relatedTarget = {
  4141.           relatedTarget: toggles[i]
  4142.         };
  4143.  
  4144.         if (!context) {
  4145.           continue;
  4146.         }
  4147.  
  4148.         var dropdownMenu = context._menu;
  4149.  
  4150.         if (!$$$1(parent).hasClass(ClassName.SHOW)) {
  4151.           continue;
  4152.         }
  4153.  
  4154.         if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
  4155.           continue;
  4156.         }
  4157.  
  4158.         var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
  4159.         $$$1(parent).trigger(hideEvent);
  4160.  
  4161.         if (hideEvent.isDefaultPrevented()) {
  4162.           continue;
  4163.         } // If this is a touch-enabled device we remove the extra
  4164.         // empty mouseover listeners we added for iOS support
  4165.  
  4166.  
  4167.         if ('ontouchstart' in document.documentElement) {
  4168.           $$$1('body').children().off('mouseover', null, $$$1.noop);
  4169.         }
  4170.  
  4171.         toggles[i].setAttribute('aria-expanded', 'false');
  4172.         $$$1(dropdownMenu).removeClass(ClassName.SHOW);
  4173.         $$$1(parent).removeClass(ClassName.SHOW).trigger($$$1.Event(Event.HIDDEN, relatedTarget));
  4174.       }
  4175.     };
  4176.  
  4177.     Dropdown._getParentFromElement = function _getParentFromElement(element) {
  4178.       var parent;
  4179.       var selector = Util.getSelectorFromElement(element);
  4180.  
  4181.       if (selector) {
  4182.         parent = $$$1(selector)[0];
  4183.       }
  4184.  
  4185.       return parent || element.parentNode;
  4186.     }; // eslint-disable-next-line complexity
  4187.  
  4188.  
  4189.     Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
  4190.       // If not input/textarea:
  4191.       //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
  4192.       // If input/textarea:
  4193.       //  - If space key => not a dropdown command
  4194.       //  - If key is other than escape
  4195.       //    - If key is not up or down => not a dropdown command
  4196.       //    - If trigger inside the menu => not a dropdown command
  4197.       if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $$$1(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
  4198.         return;
  4199.       }
  4200.  
  4201.       event.preventDefault();
  4202.       event.stopPropagation();
  4203.  
  4204.       if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
  4205.         return;
  4206.       }
  4207.  
  4208.       var parent = Dropdown._getParentFromElement(this);
  4209.  
  4210.       var isActive = $$$1(parent).hasClass(ClassName.SHOW);
  4211.  
  4212.       if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
  4213.         if (event.which === ESCAPE_KEYCODE) {
  4214.           var toggle = $$$1(parent).find(Selector.DATA_TOGGLE)[0];
  4215.           $$$1(toggle).trigger('focus');
  4216.         }
  4217.  
  4218.         $$$1(this).trigger('click');
  4219.         return;
  4220.       }
  4221.  
  4222.       var items = $$$1(parent).find(Selector.VISIBLE_ITEMS).get();
  4223.  
  4224.       if (items.length === 0) {
  4225.         return;
  4226.       }
  4227.  
  4228.       var index = items.indexOf(event.target);
  4229.  
  4230.       if (event.which === ARROW_UP_KEYCODE && index > 0) {
  4231.         // Up
  4232.         index--;
  4233.       }
  4234.  
  4235.       if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
  4236.         // Down
  4237.         index++;
  4238.       }
  4239.  
  4240.       if (index < 0) {
  4241.         index = 0;
  4242.       }
  4243.  
  4244.       items[index].focus();
  4245.     };
  4246.  
  4247.     _createClass(Dropdown, null, [{
  4248.       key: "VERSION",
  4249.       get: function get() {
  4250.         return VERSION;
  4251.       }
  4252.     }, {
  4253.       key: "Default",
  4254.       get: function get() {
  4255.         return Default;
  4256.       }
  4257.     }, {
  4258.       key: "DefaultType",
  4259.       get: function get() {
  4260.         return DefaultType;
  4261.       }
  4262.     }]);
  4263.     return Dropdown;
  4264.   }();
  4265.   /**
  4266.    * ------------------------------------------------------------------------
  4267.    * Data Api implementation
  4268.    * ------------------------------------------------------------------------
  4269.    */
  4270.  
  4271.  
  4272.   $$$1(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API + " " + Event.KEYUP_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
  4273.     event.preventDefault();
  4274.     event.stopPropagation();
  4275.  
  4276.     Dropdown._jQueryInterface.call($$$1(this), 'toggle');
  4277.   }).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) {
  4278.     e.stopPropagation();
  4279.   });
  4280.   /**
  4281.    * ------------------------------------------------------------------------
  4282.    * jQuery
  4283.    * ------------------------------------------------------------------------
  4284.    */
  4285.  
  4286.   $$$1.fn[NAME] = Dropdown._jQueryInterface;
  4287.   $$$1.fn[NAME].Constructor = Dropdown;
  4288.  
  4289.   $$$1.fn[NAME].noConflict = function () {
  4290.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  4291.     return Dropdown._jQueryInterface;
  4292.   };
  4293.  
  4294.   return Dropdown;
  4295. }($, Popper);
  4296.  
  4297. /**
  4298.  * --------------------------------------------------------------------------
  4299.  * Bootstrap (v4.0.0): modal.js
  4300.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  4301.  * --------------------------------------------------------------------------
  4302.  */
  4303.  
  4304. var Modal = function ($$$1) {
  4305.   /**
  4306.    * ------------------------------------------------------------------------
  4307.    * Constants
  4308.    * ------------------------------------------------------------------------
  4309.    */
  4310.   var NAME = 'modal';
  4311.   var VERSION = '4.0.0';
  4312.   var DATA_KEY = 'bs.modal';
  4313.   var EVENT_KEY = "." + DATA_KEY;
  4314.   var DATA_API_KEY = '.data-api';
  4315.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  4316.   var TRANSITION_DURATION = 300;
  4317.   var BACKDROP_TRANSITION_DURATION = 150;
  4318.   var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
  4319.  
  4320.   var Default = {
  4321.     backdrop: true,
  4322.     keyboard: true,
  4323.     focus: true,
  4324.     show: true
  4325.   };
  4326.   var DefaultType = {
  4327.     backdrop: '(boolean|string)',
  4328.     keyboard: 'boolean',
  4329.     focus: 'boolean',
  4330.     show: 'boolean'
  4331.   };
  4332.   var Event = {
  4333.     HIDE: "hide" + EVENT_KEY,
  4334.     HIDDEN: "hidden" + EVENT_KEY,
  4335.     SHOW: "show" + EVENT_KEY,
  4336.     SHOWN: "shown" + EVENT_KEY,
  4337.     FOCUSIN: "focusin" + EVENT_KEY,
  4338.     RESIZE: "resize" + EVENT_KEY,
  4339.     CLICK_DISMISS: "click.dismiss" + EVENT_KEY,
  4340.     KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY,
  4341.     MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY,
  4342.     MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY,
  4343.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
  4344.   };
  4345.   var ClassName = {
  4346.     SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
  4347.     BACKDROP: 'modal-backdrop',
  4348.     OPEN: 'modal-open',
  4349.     FADE: 'fade',
  4350.     SHOW: 'show'
  4351.   };
  4352.   var Selector = {
  4353.     DIALOG: '.modal-dialog',
  4354.     DATA_TOGGLE: '[data-toggle="modal"]',
  4355.     DATA_DISMISS: '[data-dismiss="modal"]',
  4356.     FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
  4357.     STICKY_CONTENT: '.sticky-top',
  4358.     NAVBAR_TOGGLER: '.navbar-toggler'
  4359.     /**
  4360.      * ------------------------------------------------------------------------
  4361.      * Class Definition
  4362.      * ------------------------------------------------------------------------
  4363.      */
  4364.  
  4365.   };
  4366.  
  4367.   var Modal =
  4368.   /*#__PURE__*/
  4369.   function () {
  4370.     function Modal(element, config) {
  4371.       this._config = this._getConfig(config);
  4372.       this._element = element;
  4373.       this._dialog = $$$1(element).find(Selector.DIALOG)[0];
  4374.       this._backdrop = null;
  4375.       this._isShown = false;
  4376.       this._isBodyOverflowing = false;
  4377.       this._ignoreBackdropClick = false;
  4378.       this._originalBodyPadding = 0;
  4379.       this._scrollbarWidth = 0;
  4380.     } // Getters
  4381.  
  4382.  
  4383.     var _proto = Modal.prototype;
  4384.  
  4385.     // Public
  4386.     _proto.toggle = function toggle(relatedTarget) {
  4387.       return this._isShown ? this.hide() : this.show(relatedTarget);
  4388.     };
  4389.  
  4390.     _proto.show = function show(relatedTarget) {
  4391.       var _this = this;
  4392.  
  4393.       if (this._isTransitioning || this._isShown) {
  4394.         return;
  4395.       }
  4396.  
  4397.       if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
  4398.         this._isTransitioning = true;
  4399.       }
  4400.  
  4401.       var showEvent = $$$1.Event(Event.SHOW, {
  4402.         relatedTarget: relatedTarget
  4403.       });
  4404.       $$$1(this._element).trigger(showEvent);
  4405.  
  4406.       if (this._isShown || showEvent.isDefaultPrevented()) {
  4407.         return;
  4408.       }
  4409.  
  4410.       this._isShown = true;
  4411.  
  4412.       this._checkScrollbar();
  4413.  
  4414.       this._setScrollbar();
  4415.  
  4416.       this._adjustDialog();
  4417.  
  4418.       $$$1(document.body).addClass(ClassName.OPEN);
  4419.  
  4420.       this._setEscapeEvent();
  4421.  
  4422.       this._setResizeEvent();
  4423.  
  4424.       $$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function (event) {
  4425.         return _this.hide(event);
  4426.       });
  4427.       $$$1(this._dialog).on(Event.MOUSEDOWN_DISMISS, function () {
  4428.         $$$1(_this._element).one(Event.MOUSEUP_DISMISS, function (event) {
  4429.           if ($$$1(event.target).is(_this._element)) {
  4430.             _this._ignoreBackdropClick = true;
  4431.           }
  4432.         });
  4433.       });
  4434.  
  4435.       this._showBackdrop(function () {
  4436.         return _this._showElement(relatedTarget);
  4437.       });
  4438.     };
  4439.  
  4440.     _proto.hide = function hide(event) {
  4441.       var _this2 = this;
  4442.  
  4443.       if (event) {
  4444.         event.preventDefault();
  4445.       }
  4446.  
  4447.       if (this._isTransitioning || !this._isShown) {
  4448.         return;
  4449.       }
  4450.  
  4451.       var hideEvent = $$$1.Event(Event.HIDE);
  4452.       $$$1(this._element).trigger(hideEvent);
  4453.  
  4454.       if (!this._isShown || hideEvent.isDefaultPrevented()) {
  4455.         return;
  4456.       }
  4457.  
  4458.       this._isShown = false;
  4459.       var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
  4460.  
  4461.       if (transition) {
  4462.         this._isTransitioning = true;
  4463.       }
  4464.  
  4465.       this._setEscapeEvent();
  4466.  
  4467.       this._setResizeEvent();
  4468.  
  4469.       $$$1(document).off(Event.FOCUSIN);
  4470.       $$$1(this._element).removeClass(ClassName.SHOW);
  4471.       $$$1(this._element).off(Event.CLICK_DISMISS);
  4472.       $$$1(this._dialog).off(Event.MOUSEDOWN_DISMISS);
  4473.  
  4474.       if (transition) {
  4475.         $$$1(this._element).one(Util.TRANSITION_END, function (event) {
  4476.           return _this2._hideModal(event);
  4477.         }).emulateTransitionEnd(TRANSITION_DURATION);
  4478.       } else {
  4479.         this._hideModal();
  4480.       }
  4481.     };
  4482.  
  4483.     _proto.dispose = function dispose() {
  4484.       $$$1.removeData(this._element, DATA_KEY);
  4485.       $$$1(window, document, this._element, this._backdrop).off(EVENT_KEY);
  4486.       this._config = null;
  4487.       this._element = null;
  4488.       this._dialog = null;
  4489.       this._backdrop = null;
  4490.       this._isShown = null;
  4491.       this._isBodyOverflowing = null;
  4492.       this._ignoreBackdropClick = null;
  4493.       this._scrollbarWidth = null;
  4494.     };
  4495.  
  4496.     _proto.handleUpdate = function handleUpdate() {
  4497.       this._adjustDialog();
  4498.     }; // Private
  4499.  
  4500.  
  4501.     _proto._getConfig = function _getConfig(config) {
  4502.       config = _extends({}, Default, config);
  4503.       Util.typeCheckConfig(NAME, config, DefaultType);
  4504.       return config;
  4505.     };
  4506.  
  4507.     _proto._showElement = function _showElement(relatedTarget) {
  4508.       var _this3 = this;
  4509.  
  4510.       var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
  4511.  
  4512.       if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
  4513.         // Don't move modal's DOM position
  4514.         document.body.appendChild(this._element);
  4515.       }
  4516.  
  4517.       this._element.style.display = 'block';
  4518.  
  4519.       this._element.removeAttribute('aria-hidden');
  4520.  
  4521.       this._element.scrollTop = 0;
  4522.  
  4523.       if (transition) {
  4524.         Util.reflow(this._element);
  4525.       }
  4526.  
  4527.       $$$1(this._element).addClass(ClassName.SHOW);
  4528.  
  4529.       if (this._config.focus) {
  4530.         this._enforceFocus();
  4531.       }
  4532.  
  4533.       var shownEvent = $$$1.Event(Event.SHOWN, {
  4534.         relatedTarget: relatedTarget
  4535.       });
  4536.  
  4537.       var transitionComplete = function transitionComplete() {
  4538.         if (_this3._config.focus) {
  4539.           _this3._element.focus();
  4540.         }
  4541.  
  4542.         _this3._isTransitioning = false;
  4543.         $$$1(_this3._element).trigger(shownEvent);
  4544.       };
  4545.  
  4546.       if (transition) {
  4547.         $$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(TRANSITION_DURATION);
  4548.       } else {
  4549.         transitionComplete();
  4550.       }
  4551.     };
  4552.  
  4553.     _proto._enforceFocus = function _enforceFocus() {
  4554.       var _this4 = this;
  4555.  
  4556.       $$$1(document).off(Event.FOCUSIN) // Guard against infinite focus loop
  4557.       .on(Event.FOCUSIN, function (event) {
  4558.         if (document !== event.target && _this4._element !== event.target && $$$1(_this4._element).has(event.target).length === 0) {
  4559.           _this4._element.focus();
  4560.         }
  4561.       });
  4562.     };
  4563.  
  4564.     _proto._setEscapeEvent = function _setEscapeEvent() {
  4565.       var _this5 = this;
  4566.  
  4567.       if (this._isShown && this._config.keyboard) {
  4568.         $$$1(this._element).on(Event.KEYDOWN_DISMISS, function (event) {
  4569.           if (event.which === ESCAPE_KEYCODE) {
  4570.             event.preventDefault();
  4571.  
  4572.             _this5.hide();
  4573.           }
  4574.         });
  4575.       } else if (!this._isShown) {
  4576.         $$$1(this._element).off(Event.KEYDOWN_DISMISS);
  4577.       }
  4578.     };
  4579.  
  4580.     _proto._setResizeEvent = function _setResizeEvent() {
  4581.       var _this6 = this;
  4582.  
  4583.       if (this._isShown) {
  4584.         $$$1(window).on(Event.RESIZE, function (event) {
  4585.           return _this6.handleUpdate(event);
  4586.         });
  4587.       } else {
  4588.         $$$1(window).off(Event.RESIZE);
  4589.       }
  4590.     };
  4591.  
  4592.     _proto._hideModal = function _hideModal() {
  4593.       var _this7 = this;
  4594.  
  4595.       this._element.style.display = 'none';
  4596.  
  4597.       this._element.setAttribute('aria-hidden', true);
  4598.  
  4599.       this._isTransitioning = false;
  4600.  
  4601.       this._showBackdrop(function () {
  4602.         $$$1(document.body).removeClass(ClassName.OPEN);
  4603.  
  4604.         _this7._resetAdjustments();
  4605.  
  4606.         _this7._resetScrollbar();
  4607.  
  4608.         $$$1(_this7._element).trigger(Event.HIDDEN);
  4609.       });
  4610.     };
  4611.  
  4612.     _proto._removeBackdrop = function _removeBackdrop() {
  4613.       if (this._backdrop) {
  4614.         $$$1(this._backdrop).remove();
  4615.         this._backdrop = null;
  4616.       }
  4617.     };
  4618.  
  4619.     _proto._showBackdrop = function _showBackdrop(callback) {
  4620.       var _this8 = this;
  4621.  
  4622.       var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
  4623.  
  4624.       if (this._isShown && this._config.backdrop) {
  4625.         var doAnimate = Util.supportsTransitionEnd() && animate;
  4626.         this._backdrop = document.createElement('div');
  4627.         this._backdrop.className = ClassName.BACKDROP;
  4628.  
  4629.         if (animate) {
  4630.           $$$1(this._backdrop).addClass(animate);
  4631.         }
  4632.  
  4633.         $$$1(this._backdrop).appendTo(document.body);
  4634.         $$$1(this._element).on(Event.CLICK_DISMISS, function (event) {
  4635.           if (_this8._ignoreBackdropClick) {
  4636.             _this8._ignoreBackdropClick = false;
  4637.             return;
  4638.           }
  4639.  
  4640.           if (event.target !== event.currentTarget) {
  4641.             return;
  4642.           }
  4643.  
  4644.           if (_this8._config.backdrop === 'static') {
  4645.             _this8._element.focus();
  4646.           } else {
  4647.             _this8.hide();
  4648.           }
  4649.         });
  4650.  
  4651.         if (doAnimate) {
  4652.           Util.reflow(this._backdrop);
  4653.         }
  4654.  
  4655.         $$$1(this._backdrop).addClass(ClassName.SHOW);
  4656.  
  4657.         if (!callback) {
  4658.           return;
  4659.         }
  4660.  
  4661.         if (!doAnimate) {
  4662.           callback();
  4663.           return;
  4664.         }
  4665.  
  4666.         $$$1(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
  4667.       } else if (!this._isShown && this._backdrop) {
  4668.         $$$1(this._backdrop).removeClass(ClassName.SHOW);
  4669.  
  4670.         var callbackRemove = function callbackRemove() {
  4671.           _this8._removeBackdrop();
  4672.  
  4673.           if (callback) {
  4674.             callback();
  4675.           }
  4676.         };
  4677.  
  4678.         if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
  4679.           $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
  4680.         } else {
  4681.           callbackRemove();
  4682.         }
  4683.       } else if (callback) {
  4684.         callback();
  4685.       }
  4686.     }; // ----------------------------------------------------------------------
  4687.     // the following methods are used to handle overflowing modals
  4688.     // todo (fat): these should probably be refactored out of modal.js
  4689.     // ----------------------------------------------------------------------
  4690.  
  4691.  
  4692.     _proto._adjustDialog = function _adjustDialog() {
  4693.       var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
  4694.  
  4695.       if (!this._isBodyOverflowing && isModalOverflowing) {
  4696.         this._element.style.paddingLeft = this._scrollbarWidth + "px";
  4697.       }
  4698.  
  4699.       if (this._isBodyOverflowing && !isModalOverflowing) {
  4700.         this._element.style.paddingRight = this._scrollbarWidth + "px";
  4701.       }
  4702.     };
  4703.  
  4704.     _proto._resetAdjustments = function _resetAdjustments() {
  4705.       this._element.style.paddingLeft = '';
  4706.       this._element.style.paddingRight = '';
  4707.     };
  4708.  
  4709.     _proto._checkScrollbar = function _checkScrollbar() {
  4710.       var rect = document.body.getBoundingClientRect();
  4711.       this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
  4712.       this._scrollbarWidth = this._getScrollbarWidth();
  4713.     };
  4714.  
  4715.     _proto._setScrollbar = function _setScrollbar() {
  4716.       var _this9 = this;
  4717.  
  4718.       if (this._isBodyOverflowing) {
  4719.         // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
  4720.         //   while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
  4721.         // Adjust fixed content padding
  4722.         $$$1(Selector.FIXED_CONTENT).each(function (index, element) {
  4723.           var actualPadding = $$$1(element)[0].style.paddingRight;
  4724.           var calculatedPadding = $$$1(element).css('padding-right');
  4725.           $$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
  4726.         }); // Adjust sticky content margin
  4727.  
  4728.         $$$1(Selector.STICKY_CONTENT).each(function (index, element) {
  4729.           var actualMargin = $$$1(element)[0].style.marginRight;
  4730.           var calculatedMargin = $$$1(element).css('margin-right');
  4731.           $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
  4732.         }); // Adjust navbar-toggler margin
  4733.  
  4734.         $$$1(Selector.NAVBAR_TOGGLER).each(function (index, element) {
  4735.           var actualMargin = $$$1(element)[0].style.marginRight;
  4736.           var calculatedMargin = $$$1(element).css('margin-right');
  4737.           $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) + _this9._scrollbarWidth + "px");
  4738.         }); // Adjust body padding
  4739.  
  4740.         var actualPadding = document.body.style.paddingRight;
  4741.         var calculatedPadding = $$$1('body').css('padding-right');
  4742.         $$$1('body').data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
  4743.       }
  4744.     };
  4745.  
  4746.     _proto._resetScrollbar = function _resetScrollbar() {
  4747.       // Restore fixed content padding
  4748.       $$$1(Selector.FIXED_CONTENT).each(function (index, element) {
  4749.         var padding = $$$1(element).data('padding-right');
  4750.  
  4751.         if (typeof padding !== 'undefined') {
  4752.           $$$1(element).css('padding-right', padding).removeData('padding-right');
  4753.         }
  4754.       }); // Restore sticky content and navbar-toggler margin
  4755.  
  4756.       $$$1(Selector.STICKY_CONTENT + ", " + Selector.NAVBAR_TOGGLER).each(function (index, element) {
  4757.         var margin = $$$1(element).data('margin-right');
  4758.  
  4759.         if (typeof margin !== 'undefined') {
  4760.           $$$1(element).css('margin-right', margin).removeData('margin-right');
  4761.         }
  4762.       }); // Restore body padding
  4763.  
  4764.       var padding = $$$1('body').data('padding-right');
  4765.  
  4766.       if (typeof padding !== 'undefined') {
  4767.         $$$1('body').css('padding-right', padding).removeData('padding-right');
  4768.       }
  4769.     };
  4770.  
  4771.     _proto._getScrollbarWidth = function _getScrollbarWidth() {
  4772.       // thx d.walsh
  4773.       var scrollDiv = document.createElement('div');
  4774.       scrollDiv.className = ClassName.SCROLLBAR_MEASURER;
  4775.       document.body.appendChild(scrollDiv);
  4776.       var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
  4777.       document.body.removeChild(scrollDiv);
  4778.       return scrollbarWidth;
  4779.     }; // Static
  4780.  
  4781.  
  4782.     Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
  4783.       return this.each(function () {
  4784.         var data = $$$1(this).data(DATA_KEY);
  4785.  
  4786.         var _config = _extends({}, Modal.Default, $$$1(this).data(), typeof config === 'object' && config);
  4787.  
  4788.         if (!data) {
  4789.           data = new Modal(this, _config);
  4790.           $$$1(this).data(DATA_KEY, data);
  4791.         }
  4792.  
  4793.         if (typeof config === 'string') {
  4794.           if (typeof data[config] === 'undefined') {
  4795.             throw new TypeError("No method named \"" + config + "\"");
  4796.           }
  4797.  
  4798.           data[config](relatedTarget);
  4799.         } else if (_config.show) {
  4800.           data.show(relatedTarget);
  4801.         }
  4802.       });
  4803.     };
  4804.  
  4805.     _createClass(Modal, null, [{
  4806.       key: "VERSION",
  4807.       get: function get() {
  4808.         return VERSION;
  4809.       }
  4810.     }, {
  4811.       key: "Default",
  4812.       get: function get() {
  4813.         return Default;
  4814.       }
  4815.     }]);
  4816.     return Modal;
  4817.   }();
  4818.   /**
  4819.    * ------------------------------------------------------------------------
  4820.    * Data Api implementation
  4821.    * ------------------------------------------------------------------------
  4822.    */
  4823.  
  4824.  
  4825.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
  4826.     var _this10 = this;
  4827.  
  4828.     var target;
  4829.     var selector = Util.getSelectorFromElement(this);
  4830.  
  4831.     if (selector) {
  4832.       target = $$$1(selector)[0];
  4833.     }
  4834.  
  4835.     var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _extends({}, $$$1(target).data(), $$$1(this).data());
  4836.  
  4837.     if (this.tagName === 'A' || this.tagName === 'AREA') {
  4838.       event.preventDefault();
  4839.     }
  4840.  
  4841.     var $target = $$$1(target).one(Event.SHOW, function (showEvent) {
  4842.       if (showEvent.isDefaultPrevented()) {
  4843.         // Only register focus restorer if modal will actually get shown
  4844.         return;
  4845.       }
  4846.  
  4847.       $target.one(Event.HIDDEN, function () {
  4848.         if ($$$1(_this10).is(':visible')) {
  4849.           _this10.focus();
  4850.         }
  4851.       });
  4852.     });
  4853.  
  4854.     Modal._jQueryInterface.call($$$1(target), config, this);
  4855.   });
  4856.   /**
  4857.    * ------------------------------------------------------------------------
  4858.    * jQuery
  4859.    * ------------------------------------------------------------------------
  4860.    */
  4861.  
  4862.   $$$1.fn[NAME] = Modal._jQueryInterface;
  4863.   $$$1.fn[NAME].Constructor = Modal;
  4864.  
  4865.   $$$1.fn[NAME].noConflict = function () {
  4866.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  4867.     return Modal._jQueryInterface;
  4868.   };
  4869.  
  4870.   return Modal;
  4871. }($);
  4872.  
  4873. /**
  4874.  * --------------------------------------------------------------------------
  4875.  * Bootstrap (v4.0.0): tooltip.js
  4876.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  4877.  * --------------------------------------------------------------------------
  4878.  */
  4879.  
  4880. var Tooltip = function ($$$1) {
  4881.   /**
  4882.    * ------------------------------------------------------------------------
  4883.    * Constants
  4884.    * ------------------------------------------------------------------------
  4885.    */
  4886.   var NAME = 'tooltip';
  4887.   var VERSION = '4.0.0';
  4888.   var DATA_KEY = 'bs.tooltip';
  4889.   var EVENT_KEY = "." + DATA_KEY;
  4890.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  4891.   var TRANSITION_DURATION = 150;
  4892.   var CLASS_PREFIX = 'bs-tooltip';
  4893.   var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
  4894.   var DefaultType = {
  4895.     animation: 'boolean',
  4896.     template: 'string',
  4897.     title: '(string|element|function)',
  4898.     trigger: 'string',
  4899.     delay: '(number|object)',
  4900.     html: 'boolean',
  4901.     selector: '(string|boolean)',
  4902.     placement: '(string|function)',
  4903.     offset: '(number|string)',
  4904.     container: '(string|element|boolean)',
  4905.     fallbackPlacement: '(string|array)',
  4906.     boundary: '(string|element)'
  4907.   };
  4908.   var AttachmentMap = {
  4909.     AUTO: 'auto',
  4910.     TOP: 'top',
  4911.     RIGHT: 'right',
  4912.     BOTTOM: 'bottom',
  4913.     LEFT: 'left'
  4914.   };
  4915.   var Default = {
  4916.     animation: true,
  4917.     template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
  4918.     trigger: 'hover focus',
  4919.     title: '',
  4920.     delay: 0,
  4921.     html: false,
  4922.     selector: false,
  4923.     placement: 'top',
  4924.     offset: 0,
  4925.     container: false,
  4926.     fallbackPlacement: 'flip',
  4927.     boundary: 'scrollParent'
  4928.   };
  4929.   var HoverState = {
  4930.     SHOW: 'show',
  4931.     OUT: 'out'
  4932.   };
  4933.   var Event = {
  4934.     HIDE: "hide" + EVENT_KEY,
  4935.     HIDDEN: "hidden" + EVENT_KEY,
  4936.     SHOW: "show" + EVENT_KEY,
  4937.     SHOWN: "shown" + EVENT_KEY,
  4938.     INSERTED: "inserted" + EVENT_KEY,
  4939.     CLICK: "click" + EVENT_KEY,
  4940.     FOCUSIN: "focusin" + EVENT_KEY,
  4941.     FOCUSOUT: "focusout" + EVENT_KEY,
  4942.     MOUSEENTER: "mouseenter" + EVENT_KEY,
  4943.     MOUSELEAVE: "mouseleave" + EVENT_KEY
  4944.   };
  4945.   var ClassName = {
  4946.     FADE: 'fade',
  4947.     SHOW: 'show'
  4948.   };
  4949.   var Selector = {
  4950.     TOOLTIP: '.tooltip',
  4951.     TOOLTIP_INNER: '.tooltip-inner',
  4952.     ARROW: '.arrow'
  4953.   };
  4954.   var Trigger = {
  4955.     HOVER: 'hover',
  4956.     FOCUS: 'focus',
  4957.     CLICK: 'click',
  4958.     MANUAL: 'manual'
  4959.     /**
  4960.      * ------------------------------------------------------------------------
  4961.      * Class Definition
  4962.      * ------------------------------------------------------------------------
  4963.      */
  4964.  
  4965.   };
  4966.  
  4967.   var Tooltip =
  4968.   /*#__PURE__*/
  4969.   function () {
  4970.     function Tooltip(element, config) {
  4971.       /**
  4972.        * Check for Popper dependency
  4973.        * Popper - https://popper.js.org
  4974.        */
  4975.       if (typeof Popper === 'undefined') {
  4976.         throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
  4977.       } // private
  4978.  
  4979.  
  4980.       this._isEnabled = true;
  4981.       this._timeout = 0;
  4982.       this._hoverState = '';
  4983.       this._activeTrigger = {};
  4984.       this._popper = null; // Protected
  4985.  
  4986.       this.element = element;
  4987.       this.config = this._getConfig(config);
  4988.       this.tip = null;
  4989.  
  4990.       this._setListeners();
  4991.     } // Getters
  4992.  
  4993.  
  4994.     var _proto = Tooltip.prototype;
  4995.  
  4996.     // Public
  4997.     _proto.enable = function enable() {
  4998.       this._isEnabled = true;
  4999.     };
  5000.  
  5001.     _proto.disable = function disable() {
  5002.       this._isEnabled = false;
  5003.     };
  5004.  
  5005.     _proto.toggleEnabled = function toggleEnabled() {
  5006.       this._isEnabled = !this._isEnabled;
  5007.     };
  5008.  
  5009.     _proto.toggle = function toggle(event) {
  5010.       if (!this._isEnabled) {
  5011.         return;
  5012.       }
  5013.  
  5014.       if (event) {
  5015.         var dataKey = this.constructor.DATA_KEY;
  5016.         var context = $$$1(event.currentTarget).data(dataKey);
  5017.  
  5018.         if (!context) {
  5019.           context = new this.constructor(event.currentTarget, this._getDelegateConfig());
  5020.           $$$1(event.currentTarget).data(dataKey, context);
  5021.         }
  5022.  
  5023.         context._activeTrigger.click = !context._activeTrigger.click;
  5024.  
  5025.         if (context._isWithActiveTrigger()) {
  5026.           context._enter(null, context);
  5027.         } else {
  5028.           context._leave(null, context);
  5029.         }
  5030.       } else {
  5031.         if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
  5032.           this._leave(null, this);
  5033.  
  5034.           return;
  5035.         }
  5036.  
  5037.         this._enter(null, this);
  5038.       }
  5039.     };
  5040.  
  5041.     _proto.dispose = function dispose() {
  5042.       clearTimeout(this._timeout);
  5043.       $$$1.removeData(this.element, this.constructor.DATA_KEY);
  5044.       $$$1(this.element).off(this.constructor.EVENT_KEY);
  5045.       $$$1(this.element).closest('.modal').off('hide.bs.modal');
  5046.  
  5047.       if (this.tip) {
  5048.         $$$1(this.tip).remove();
  5049.       }
  5050.  
  5051.       this._isEnabled = null;
  5052.       this._timeout = null;
  5053.       this._hoverState = null;
  5054.       this._activeTrigger = null;
  5055.  
  5056.       if (this._popper !== null) {
  5057.         this._popper.destroy();
  5058.       }
  5059.  
  5060.       this._popper = null;
  5061.       this.element = null;
  5062.       this.config = null;
  5063.       this.tip = null;
  5064.     };
  5065.  
  5066.     _proto.show = function show() {
  5067.       var _this = this;
  5068.  
  5069.       if ($$$1(this.element).css('display') === 'none') {
  5070.         throw new Error('Please use show on visible elements');
  5071.       }
  5072.  
  5073.       var showEvent = $$$1.Event(this.constructor.Event.SHOW);
  5074.  
  5075.       if (this.isWithContent() && this._isEnabled) {
  5076.         $$$1(this.element).trigger(showEvent);
  5077.         var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
  5078.  
  5079.         if (showEvent.isDefaultPrevented() || !isInTheDom) {
  5080.           return;
  5081.         }
  5082.  
  5083.         var tip = this.getTipElement();
  5084.         var tipId = Util.getUID(this.constructor.NAME);
  5085.         tip.setAttribute('id', tipId);
  5086.         this.element.setAttribute('aria-describedby', tipId);
  5087.         this.setContent();
  5088.  
  5089.         if (this.config.animation) {
  5090.           $$$1(tip).addClass(ClassName.FADE);
  5091.         }
  5092.  
  5093.         var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
  5094.  
  5095.         var attachment = this._getAttachment(placement);
  5096.  
  5097.         this.addAttachmentClass(attachment);
  5098.         var container = this.config.container === false ? document.body : $$$1(this.config.container);
  5099.         $$$1(tip).data(this.constructor.DATA_KEY, this);
  5100.  
  5101.         if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
  5102.           $$$1(tip).appendTo(container);
  5103.         }
  5104.  
  5105.         $$$1(this.element).trigger(this.constructor.Event.INSERTED);
  5106.         this._popper = new Popper(this.element, tip, {
  5107.           placement: attachment,
  5108.           modifiers: {
  5109.             offset: {
  5110.               offset: this.config.offset
  5111.             },
  5112.             flip: {
  5113.               behavior: this.config.fallbackPlacement
  5114.             },
  5115.             arrow: {
  5116.               element: Selector.ARROW
  5117.             },
  5118.             preventOverflow: {
  5119.               boundariesElement: this.config.boundary
  5120.             }
  5121.           },
  5122.           onCreate: function onCreate(data) {
  5123.             if (data.originalPlacement !== data.placement) {
  5124.               _this._handlePopperPlacementChange(data);
  5125.             }
  5126.           },
  5127.           onUpdate: function onUpdate(data) {
  5128.             _this._handlePopperPlacementChange(data);
  5129.           }
  5130.         });
  5131.         $$$1(tip).addClass(ClassName.SHOW); // If this is a touch-enabled device we add extra
  5132.         // empty mouseover listeners to the body's immediate children;
  5133.         // only needed because of broken event delegation on iOS
  5134.         // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
  5135.  
  5136.         if ('ontouchstart' in document.documentElement) {
  5137.           $$$1('body').children().on('mouseover', null, $$$1.noop);
  5138.         }
  5139.  
  5140.         var complete = function complete() {
  5141.           if (_this.config.animation) {
  5142.             _this._fixTransition();
  5143.           }
  5144.  
  5145.           var prevHoverState = _this._hoverState;
  5146.           _this._hoverState = null;
  5147.           $$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
  5148.  
  5149.           if (prevHoverState === HoverState.OUT) {
  5150.             _this._leave(null, _this);
  5151.           }
  5152.         };
  5153.  
  5154.         if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
  5155.           $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION);
  5156.         } else {
  5157.           complete();
  5158.         }
  5159.       }
  5160.     };
  5161.  
  5162.     _proto.hide = function hide(callback) {
  5163.       var _this2 = this;
  5164.  
  5165.       var tip = this.getTipElement();
  5166.       var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
  5167.  
  5168.       var complete = function complete() {
  5169.         if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
  5170.           tip.parentNode.removeChild(tip);
  5171.         }
  5172.  
  5173.         _this2._cleanTipClass();
  5174.  
  5175.         _this2.element.removeAttribute('aria-describedby');
  5176.  
  5177.         $$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
  5178.  
  5179.         if (_this2._popper !== null) {
  5180.           _this2._popper.destroy();
  5181.         }
  5182.  
  5183.         if (callback) {
  5184.           callback();
  5185.         }
  5186.       };
  5187.  
  5188.       $$$1(this.element).trigger(hideEvent);
  5189.  
  5190.       if (hideEvent.isDefaultPrevented()) {
  5191.         return;
  5192.       }
  5193.  
  5194.       $$$1(tip).removeClass(ClassName.SHOW); // If this is a touch-enabled device we remove the extra
  5195.       // empty mouseover listeners we added for iOS support
  5196.  
  5197.       if ('ontouchstart' in document.documentElement) {
  5198.         $$$1('body').children().off('mouseover', null, $$$1.noop);
  5199.       }
  5200.  
  5201.       this._activeTrigger[Trigger.CLICK] = false;
  5202.       this._activeTrigger[Trigger.FOCUS] = false;
  5203.       this._activeTrigger[Trigger.HOVER] = false;
  5204.  
  5205.       if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
  5206.         $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
  5207.       } else {
  5208.         complete();
  5209.       }
  5210.  
  5211.       this._hoverState = '';
  5212.     };
  5213.  
  5214.     _proto.update = function update() {
  5215.       if (this._popper !== null) {
  5216.         this._popper.scheduleUpdate();
  5217.       }
  5218.     }; // Protected
  5219.  
  5220.  
  5221.     _proto.isWithContent = function isWithContent() {
  5222.       return Boolean(this.getTitle());
  5223.     };
  5224.  
  5225.     _proto.addAttachmentClass = function addAttachmentClass(attachment) {
  5226.       $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
  5227.     };
  5228.  
  5229.     _proto.getTipElement = function getTipElement() {
  5230.       this.tip = this.tip || $$$1(this.config.template)[0];
  5231.       return this.tip;
  5232.     };
  5233.  
  5234.     _proto.setContent = function setContent() {
  5235.       var $tip = $$$1(this.getTipElement());
  5236.       this.setElementContent($tip.find(Selector.TOOLTIP_INNER), this.getTitle());
  5237.       $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
  5238.     };
  5239.  
  5240.     _proto.setElementContent = function setElementContent($element, content) {
  5241.       var html = this.config.html;
  5242.  
  5243.       if (typeof content === 'object' && (content.nodeType || content.jquery)) {
  5244.         // Content is a DOM node or a jQuery
  5245.         if (html) {
  5246.           if (!$$$1(content).parent().is($element)) {
  5247.             $element.empty().append(content);
  5248.           }
  5249.         } else {
  5250.           $element.text($$$1(content).text());
  5251.         }
  5252.       } else {
  5253.         $element[html ? 'html' : 'text'](content);
  5254.       }
  5255.     };
  5256.  
  5257.     _proto.getTitle = function getTitle() {
  5258.       var title = this.element.getAttribute('data-original-title');
  5259.  
  5260.       if (!title) {
  5261.         title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
  5262.       }
  5263.  
  5264.       return title;
  5265.     }; // Private
  5266.  
  5267.  
  5268.     _proto._getAttachment = function _getAttachment(placement) {
  5269.       return AttachmentMap[placement.toUpperCase()];
  5270.     };
  5271.  
  5272.     _proto._setListeners = function _setListeners() {
  5273.       var _this3 = this;
  5274.  
  5275.       var triggers = this.config.trigger.split(' ');
  5276.       triggers.forEach(function (trigger) {
  5277.         if (trigger === 'click') {
  5278.           $$$1(_this3.element).on(_this3.constructor.Event.CLICK, _this3.config.selector, function (event) {
  5279.             return _this3.toggle(event);
  5280.           });
  5281.         } else if (trigger !== Trigger.MANUAL) {
  5282.           var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
  5283.           var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
  5284.           $$$1(_this3.element).on(eventIn, _this3.config.selector, function (event) {
  5285.             return _this3._enter(event);
  5286.           }).on(eventOut, _this3.config.selector, function (event) {
  5287.             return _this3._leave(event);
  5288.           });
  5289.         }
  5290.  
  5291.         $$$1(_this3.element).closest('.modal').on('hide.bs.modal', function () {
  5292.           return _this3.hide();
  5293.         });
  5294.       });
  5295.  
  5296.       if (this.config.selector) {
  5297.         this.config = _extends({}, this.config, {
  5298.           trigger: 'manual',
  5299.           selector: ''
  5300.         });
  5301.       } else {
  5302.         this._fixTitle();
  5303.       }
  5304.     };
  5305.  
  5306.     _proto._fixTitle = function _fixTitle() {
  5307.       var titleType = typeof this.element.getAttribute('data-original-title');
  5308.  
  5309.       if (this.element.getAttribute('title') || titleType !== 'string') {
  5310.         this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
  5311.         this.element.setAttribute('title', '');
  5312.       }
  5313.     };
  5314.  
  5315.     _proto._enter = function _enter(event, context) {
  5316.       var dataKey = this.constructor.DATA_KEY;
  5317.       context = context || $$$1(event.currentTarget).data(dataKey);
  5318.  
  5319.       if (!context) {
  5320.         context = new this.constructor(event.currentTarget, this._getDelegateConfig());
  5321.         $$$1(event.currentTarget).data(dataKey, context);
  5322.       }
  5323.  
  5324.       if (event) {
  5325.         context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
  5326.       }
  5327.  
  5328.       if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
  5329.         context._hoverState = HoverState.SHOW;
  5330.         return;
  5331.       }
  5332.  
  5333.       clearTimeout(context._timeout);
  5334.       context._hoverState = HoverState.SHOW;
  5335.  
  5336.       if (!context.config.delay || !context.config.delay.show) {
  5337.         context.show();
  5338.         return;
  5339.       }
  5340.  
  5341.       context._timeout = setTimeout(function () {
  5342.         if (context._hoverState === HoverState.SHOW) {
  5343.           context.show();
  5344.         }
  5345.       }, context.config.delay.show);
  5346.     };
  5347.  
  5348.     _proto._leave = function _leave(event, context) {
  5349.       var dataKey = this.constructor.DATA_KEY;
  5350.       context = context || $$$1(event.currentTarget).data(dataKey);
  5351.  
  5352.       if (!context) {
  5353.         context = new this.constructor(event.currentTarget, this._getDelegateConfig());
  5354.         $$$1(event.currentTarget).data(dataKey, context);
  5355.       }
  5356.  
  5357.       if (event) {
  5358.         context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
  5359.       }
  5360.  
  5361.       if (context._isWithActiveTrigger()) {
  5362.         return;
  5363.       }
  5364.  
  5365.       clearTimeout(context._timeout);
  5366.       context._hoverState = HoverState.OUT;
  5367.  
  5368.       if (!context.config.delay || !context.config.delay.hide) {
  5369.         context.hide();
  5370.         return;
  5371.       }
  5372.  
  5373.       context._timeout = setTimeout(function () {
  5374.         if (context._hoverState === HoverState.OUT) {
  5375.           context.hide();
  5376.         }
  5377.       }, context.config.delay.hide);
  5378.     };
  5379.  
  5380.     _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
  5381.       for (var trigger in this._activeTrigger) {
  5382.         if (this._activeTrigger[trigger]) {
  5383.           return true;
  5384.         }
  5385.       }
  5386.  
  5387.       return false;
  5388.     };
  5389.  
  5390.     _proto._getConfig = function _getConfig(config) {
  5391.       config = _extends({}, this.constructor.Default, $$$1(this.element).data(), config);
  5392.  
  5393.       if (typeof config.delay === 'number') {
  5394.         config.delay = {
  5395.           show: config.delay,
  5396.           hide: config.delay
  5397.         };
  5398.       }
  5399.  
  5400.       if (typeof config.title === 'number') {
  5401.         config.title = config.title.toString();
  5402.       }
  5403.  
  5404.       if (typeof config.content === 'number') {
  5405.         config.content = config.content.toString();
  5406.       }
  5407.  
  5408.       Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
  5409.       return config;
  5410.     };
  5411.  
  5412.     _proto._getDelegateConfig = function _getDelegateConfig() {
  5413.       var config = {};
  5414.  
  5415.       if (this.config) {
  5416.         for (var key in this.config) {
  5417.           if (this.constructor.Default[key] !== this.config[key]) {
  5418.             config[key] = this.config[key];
  5419.           }
  5420.         }
  5421.       }
  5422.  
  5423.       return config;
  5424.     };
  5425.  
  5426.     _proto._cleanTipClass = function _cleanTipClass() {
  5427.       var $tip = $$$1(this.getTipElement());
  5428.       var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
  5429.  
  5430.       if (tabClass !== null && tabClass.length > 0) {
  5431.         $tip.removeClass(tabClass.join(''));
  5432.       }
  5433.     };
  5434.  
  5435.     _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(data) {
  5436.       this._cleanTipClass();
  5437.  
  5438.       this.addAttachmentClass(this._getAttachment(data.placement));
  5439.     };
  5440.  
  5441.     _proto._fixTransition = function _fixTransition() {
  5442.       var tip = this.getTipElement();
  5443.       var initConfigAnimation = this.config.animation;
  5444.  
  5445.       if (tip.getAttribute('x-placement') !== null) {
  5446.         return;
  5447.       }
  5448.  
  5449.       $$$1(tip).removeClass(ClassName.FADE);
  5450.       this.config.animation = false;
  5451.       this.hide();
  5452.       this.show();
  5453.       this.config.animation = initConfigAnimation;
  5454.     }; // Static
  5455.  
  5456.  
  5457.     Tooltip._jQueryInterface = function _jQueryInterface(config) {
  5458.       return this.each(function () {
  5459.         var data = $$$1(this).data(DATA_KEY);
  5460.  
  5461.         var _config = typeof config === 'object' && config;
  5462.  
  5463.         if (!data && /dispose|hide/.test(config)) {
  5464.           return;
  5465.         }
  5466.  
  5467.         if (!data) {
  5468.           data = new Tooltip(this, _config);
  5469.           $$$1(this).data(DATA_KEY, data);
  5470.         }
  5471.  
  5472.         if (typeof config === 'string') {
  5473.           if (typeof data[config] === 'undefined') {
  5474.             throw new TypeError("No method named \"" + config + "\"");
  5475.           }
  5476.  
  5477.           data[config]();
  5478.         }
  5479.       });
  5480.     };
  5481.  
  5482.     _createClass(Tooltip, null, [{
  5483.       key: "VERSION",
  5484.       get: function get() {
  5485.         return VERSION;
  5486.       }
  5487.     }, {
  5488.       key: "Default",
  5489.       get: function get() {
  5490.         return Default;
  5491.       }
  5492.     }, {
  5493.       key: "NAME",
  5494.       get: function get() {
  5495.         return NAME;
  5496.       }
  5497.     }, {
  5498.       key: "DATA_KEY",
  5499.       get: function get() {
  5500.         return DATA_KEY;
  5501.       }
  5502.     }, {
  5503.       key: "Event",
  5504.       get: function get() {
  5505.         return Event;
  5506.       }
  5507.     }, {
  5508.       key: "EVENT_KEY",
  5509.       get: function get() {
  5510.         return EVENT_KEY;
  5511.       }
  5512.     }, {
  5513.       key: "DefaultType",
  5514.       get: function get() {
  5515.         return DefaultType;
  5516.       }
  5517.     }]);
  5518.     return Tooltip;
  5519.   }();
  5520.   /**
  5521.    * ------------------------------------------------------------------------
  5522.    * jQuery
  5523.    * ------------------------------------------------------------------------
  5524.    */
  5525.  
  5526.  
  5527.   $$$1.fn[NAME] = Tooltip._jQueryInterface;
  5528.   $$$1.fn[NAME].Constructor = Tooltip;
  5529.  
  5530.   $$$1.fn[NAME].noConflict = function () {
  5531.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  5532.     return Tooltip._jQueryInterface;
  5533.   };
  5534.  
  5535.   return Tooltip;
  5536. }($, Popper);
  5537.  
  5538. /**
  5539.  * --------------------------------------------------------------------------
  5540.  * Bootstrap (v4.0.0): popover.js
  5541.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  5542.  * --------------------------------------------------------------------------
  5543.  */
  5544.  
  5545. var Popover = function ($$$1) {
  5546.   /**
  5547.    * ------------------------------------------------------------------------
  5548.    * Constants
  5549.    * ------------------------------------------------------------------------
  5550.    */
  5551.   var NAME = 'popover';
  5552.   var VERSION = '4.0.0';
  5553.   var DATA_KEY = 'bs.popover';
  5554.   var EVENT_KEY = "." + DATA_KEY;
  5555.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  5556.   var CLASS_PREFIX = 'bs-popover';
  5557.   var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
  5558.   var Default = _extends({}, Tooltip.Default, {
  5559.     placement: 'right',
  5560.     trigger: 'click',
  5561.     content: '',
  5562.     template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
  5563.   });
  5564.   var DefaultType = _extends({}, Tooltip.DefaultType, {
  5565.     content: '(string|element|function)'
  5566.   });
  5567.   var ClassName = {
  5568.     FADE: 'fade',
  5569.     SHOW: 'show'
  5570.   };
  5571.   var Selector = {
  5572.     TITLE: '.popover-header',
  5573.     CONTENT: '.popover-body'
  5574.   };
  5575.   var Event = {
  5576.     HIDE: "hide" + EVENT_KEY,
  5577.     HIDDEN: "hidden" + EVENT_KEY,
  5578.     SHOW: "show" + EVENT_KEY,
  5579.     SHOWN: "shown" + EVENT_KEY,
  5580.     INSERTED: "inserted" + EVENT_KEY,
  5581.     CLICK: "click" + EVENT_KEY,
  5582.     FOCUSIN: "focusin" + EVENT_KEY,
  5583.     FOCUSOUT: "focusout" + EVENT_KEY,
  5584.     MOUSEENTER: "mouseenter" + EVENT_KEY,
  5585.     MOUSELEAVE: "mouseleave" + EVENT_KEY
  5586.     /**
  5587.      * ------------------------------------------------------------------------
  5588.      * Class Definition
  5589.      * ------------------------------------------------------------------------
  5590.      */
  5591.  
  5592.   };
  5593.  
  5594.   var Popover =
  5595.   /*#__PURE__*/
  5596.   function (_Tooltip) {
  5597.     _inheritsLoose(Popover, _Tooltip);
  5598.  
  5599.     function Popover() {
  5600.       return _Tooltip.apply(this, arguments) || this;
  5601.     }
  5602.  
  5603.     var _proto = Popover.prototype;
  5604.  
  5605.     // Overrides
  5606.     _proto.isWithContent = function isWithContent() {
  5607.       return this.getTitle() || this._getContent();
  5608.     };
  5609.  
  5610.     _proto.addAttachmentClass = function addAttachmentClass(attachment) {
  5611.       $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
  5612.     };
  5613.  
  5614.     _proto.getTipElement = function getTipElement() {
  5615.       this.tip = this.tip || $$$1(this.config.template)[0];
  5616.       return this.tip;
  5617.     };
  5618.  
  5619.     _proto.setContent = function setContent() {
  5620.       var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
  5621.  
  5622.       this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
  5623.  
  5624.       var content = this._getContent();
  5625.  
  5626.       if (typeof content === 'function') {
  5627.         content = content.call(this.element);
  5628.       }
  5629.  
  5630.       this.setElementContent($tip.find(Selector.CONTENT), content);
  5631.       $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
  5632.     }; // Private
  5633.  
  5634.  
  5635.     _proto._getContent = function _getContent() {
  5636.       return this.element.getAttribute('data-content') || this.config.content;
  5637.     };
  5638.  
  5639.     _proto._cleanTipClass = function _cleanTipClass() {
  5640.       var $tip = $$$1(this.getTipElement());
  5641.       var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
  5642.  
  5643.       if (tabClass !== null && tabClass.length > 0) {
  5644.         $tip.removeClass(tabClass.join(''));
  5645.       }
  5646.     }; // Static
  5647.  
  5648.  
  5649.     Popover._jQueryInterface = function _jQueryInterface(config) {
  5650.       return this.each(function () {
  5651.         var data = $$$1(this).data(DATA_KEY);
  5652.  
  5653.         var _config = typeof config === 'object' ? config : null;
  5654.  
  5655.         if (!data && /destroy|hide/.test(config)) {
  5656.           return;
  5657.         }
  5658.  
  5659.         if (!data) {
  5660.           data = new Popover(this, _config);
  5661.           $$$1(this).data(DATA_KEY, data);
  5662.         }
  5663.  
  5664.         if (typeof config === 'string') {
  5665.           if (typeof data[config] === 'undefined') {
  5666.             throw new TypeError("No method named \"" + config + "\"");
  5667.           }
  5668.  
  5669.           data[config]();
  5670.         }
  5671.       });
  5672.     };
  5673.  
  5674.     _createClass(Popover, null, [{
  5675.       key: "VERSION",
  5676.       // Getters
  5677.       get: function get() {
  5678.         return VERSION;
  5679.       }
  5680.     }, {
  5681.       key: "Default",
  5682.       get: function get() {
  5683.         return Default;
  5684.       }
  5685.     }, {
  5686.       key: "NAME",
  5687.       get: function get() {
  5688.         return NAME;
  5689.       }
  5690.     }, {
  5691.       key: "DATA_KEY",
  5692.       get: function get() {
  5693.         return DATA_KEY;
  5694.       }
  5695.     }, {
  5696.       key: "Event",
  5697.       get: function get() {
  5698.         return Event;
  5699.       }
  5700.     }, {
  5701.       key: "EVENT_KEY",
  5702.       get: function get() {
  5703.         return EVENT_KEY;
  5704.       }
  5705.     }, {
  5706.       key: "DefaultType",
  5707.       get: function get() {
  5708.         return DefaultType;
  5709.       }
  5710.     }]);
  5711.     return Popover;
  5712.   }(Tooltip);
  5713.   /**
  5714.    * ------------------------------------------------------------------------
  5715.    * jQuery
  5716.    * ------------------------------------------------------------------------
  5717.    */
  5718.  
  5719.  
  5720.   $$$1.fn[NAME] = Popover._jQueryInterface;
  5721.   $$$1.fn[NAME].Constructor = Popover;
  5722.  
  5723.   $$$1.fn[NAME].noConflict = function () {
  5724.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  5725.     return Popover._jQueryInterface;
  5726.   };
  5727.  
  5728.   return Popover;
  5729. }($);
  5730.  
  5731. /**
  5732.  * --------------------------------------------------------------------------
  5733.  * Bootstrap (v4.0.0): scrollspy.js
  5734.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  5735.  * --------------------------------------------------------------------------
  5736.  */
  5737.  
  5738. var ScrollSpy = function ($$$1) {
  5739.   /**
  5740.    * ------------------------------------------------------------------------
  5741.    * Constants
  5742.    * ------------------------------------------------------------------------
  5743.    */
  5744.   var NAME = 'scrollspy';
  5745.   var VERSION = '4.0.0';
  5746.   var DATA_KEY = 'bs.scrollspy';
  5747.   var EVENT_KEY = "." + DATA_KEY;
  5748.   var DATA_API_KEY = '.data-api';
  5749.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  5750.   var Default = {
  5751.     offset: 10,
  5752.     method: 'auto',
  5753.     target: ''
  5754.   };
  5755.   var DefaultType = {
  5756.     offset: 'number',
  5757.     method: 'string',
  5758.     target: '(string|element)'
  5759.   };
  5760.   var Event = {
  5761.     ACTIVATE: "activate" + EVENT_KEY,
  5762.     SCROLL: "scroll" + EVENT_KEY,
  5763.     LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
  5764.   };
  5765.   var ClassName = {
  5766.     DROPDOWN_ITEM: 'dropdown-item',
  5767.     DROPDOWN_MENU: 'dropdown-menu',
  5768.     ACTIVE: 'active'
  5769.   };
  5770.   var Selector = {
  5771.     DATA_SPY: '[data-spy="scroll"]',
  5772.     ACTIVE: '.active',
  5773.     NAV_LIST_GROUP: '.nav, .list-group',
  5774.     NAV_LINKS: '.nav-link',
  5775.     NAV_ITEMS: '.nav-item',
  5776.     LIST_ITEMS: '.list-group-item',
  5777.     DROPDOWN: '.dropdown',
  5778.     DROPDOWN_ITEMS: '.dropdown-item',
  5779.     DROPDOWN_TOGGLE: '.dropdown-toggle'
  5780.   };
  5781.   var OffsetMethod = {
  5782.     OFFSET: 'offset',
  5783.     POSITION: 'position'
  5784.     /**
  5785.      * ------------------------------------------------------------------------
  5786.      * Class Definition
  5787.      * ------------------------------------------------------------------------
  5788.      */
  5789.  
  5790.   };
  5791.  
  5792.   var ScrollSpy =
  5793.   /*#__PURE__*/
  5794.   function () {
  5795.     function ScrollSpy(element, config) {
  5796.       var _this = this;
  5797.  
  5798.       this._element = element;
  5799.       this._scrollElement = element.tagName === 'BODY' ? window : element;
  5800.       this._config = this._getConfig(config);
  5801.       this._selector = this._config.target + " " + Selector.NAV_LINKS + "," + (this._config.target + " " + Selector.LIST_ITEMS + ",") + (this._config.target + " " + Selector.DROPDOWN_ITEMS);
  5802.       this._offsets = [];
  5803.       this._targets = [];
  5804.       this._activeTarget = null;
  5805.       this._scrollHeight = 0;
  5806.       $$$1(this._scrollElement).on(Event.SCROLL, function (event) {
  5807.         return _this._process(event);
  5808.       });
  5809.       this.refresh();
  5810.  
  5811.       this._process();
  5812.     } // Getters
  5813.  
  5814.  
  5815.     var _proto = ScrollSpy.prototype;
  5816.  
  5817.     // Public
  5818.     _proto.refresh = function refresh() {
  5819.       var _this2 = this;
  5820.  
  5821.       var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
  5822.       var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
  5823.       var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
  5824.       this._offsets = [];
  5825.       this._targets = [];
  5826.       this._scrollHeight = this._getScrollHeight();
  5827.       var targets = $$$1.makeArray($$$1(this._selector));
  5828.       targets.map(function (element) {
  5829.         var target;
  5830.         var targetSelector = Util.getSelectorFromElement(element);
  5831.  
  5832.         if (targetSelector) {
  5833.           target = $$$1(targetSelector)[0];
  5834.         }
  5835.  
  5836.         if (target) {
  5837.           var targetBCR = target.getBoundingClientRect();
  5838.  
  5839.           if (targetBCR.width || targetBCR.height) {
  5840.             // TODO (fat): remove sketch reliance on jQuery position/offset
  5841.             return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
  5842.           }
  5843.         }
  5844.  
  5845.         return null;
  5846.       }).filter(function (item) {
  5847.         return item;
  5848.       }).sort(function (a, b) {
  5849.         return a[0] - b[0];
  5850.       }).forEach(function (item) {
  5851.         _this2._offsets.push(item[0]);
  5852.  
  5853.         _this2._targets.push(item[1]);
  5854.       });
  5855.     };
  5856.  
  5857.     _proto.dispose = function dispose() {
  5858.       $$$1.removeData(this._element, DATA_KEY);
  5859.       $$$1(this._scrollElement).off(EVENT_KEY);
  5860.       this._element = null;
  5861.       this._scrollElement = null;
  5862.       this._config = null;
  5863.       this._selector = null;
  5864.       this._offsets = null;
  5865.       this._targets = null;
  5866.       this._activeTarget = null;
  5867.       this._scrollHeight = null;
  5868.     }; // Private
  5869.  
  5870.  
  5871.     _proto._getConfig = function _getConfig(config) {
  5872.       config = _extends({}, Default, config);
  5873.  
  5874.       if (typeof config.target !== 'string') {
  5875.         var id = $$$1(config.target).attr('id');
  5876.  
  5877.         if (!id) {
  5878.           id = Util.getUID(NAME);
  5879.           $$$1(config.target).attr('id', id);
  5880.         }
  5881.  
  5882.         config.target = "#" + id;
  5883.       }
  5884.  
  5885.       Util.typeCheckConfig(NAME, config, DefaultType);
  5886.       return config;
  5887.     };
  5888.  
  5889.     _proto._getScrollTop = function _getScrollTop() {
  5890.       return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
  5891.     };
  5892.  
  5893.     _proto._getScrollHeight = function _getScrollHeight() {
  5894.       return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
  5895.     };
  5896.  
  5897.     _proto._getOffsetHeight = function _getOffsetHeight() {
  5898.       return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
  5899.     };
  5900.  
  5901.     _proto._process = function _process() {
  5902.       var scrollTop = this._getScrollTop() + this._config.offset;
  5903.  
  5904.       var scrollHeight = this._getScrollHeight();
  5905.  
  5906.       var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
  5907.  
  5908.       if (this._scrollHeight !== scrollHeight) {
  5909.         this.refresh();
  5910.       }
  5911.  
  5912.       if (scrollTop >= maxScroll) {
  5913.         var target = this._targets[this._targets.length - 1];
  5914.  
  5915.         if (this._activeTarget !== target) {
  5916.           this._activate(target);
  5917.         }
  5918.  
  5919.         return;
  5920.       }
  5921.  
  5922.       if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
  5923.         this._activeTarget = null;
  5924.  
  5925.         this._clear();
  5926.  
  5927.         return;
  5928.       }
  5929.  
  5930.       for (var i = this._offsets.length; i--;) {
  5931.         var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
  5932.  
  5933.         if (isActiveTarget) {
  5934.           this._activate(this._targets[i]);
  5935.         }
  5936.       }
  5937.     };
  5938.  
  5939.     _proto._activate = function _activate(target) {
  5940.       this._activeTarget = target;
  5941.  
  5942.       this._clear();
  5943.  
  5944.       var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style
  5945.  
  5946.  
  5947.       queries = queries.map(function (selector) {
  5948.         return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
  5949.       });
  5950.       var $link = $$$1(queries.join(','));
  5951.  
  5952.       if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
  5953.         $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
  5954.         $link.addClass(ClassName.ACTIVE);
  5955.       } else {
  5956.         // Set triggered link as active
  5957.         $link.addClass(ClassName.ACTIVE); // Set triggered links parents as active
  5958.         // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
  5959.  
  5960.         $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_LINKS + ", " + Selector.LIST_ITEMS).addClass(ClassName.ACTIVE); // Handle special case when .nav-link is inside .nav-item
  5961.  
  5962.         $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE);
  5963.       }
  5964.  
  5965.       $$$1(this._scrollElement).trigger(Event.ACTIVATE, {
  5966.         relatedTarget: target
  5967.       });
  5968.     };
  5969.  
  5970.     _proto._clear = function _clear() {
  5971.       $$$1(this._selector).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
  5972.     }; // Static
  5973.  
  5974.  
  5975.     ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
  5976.       return this.each(function () {
  5977.         var data = $$$1(this).data(DATA_KEY);
  5978.  
  5979.         var _config = typeof config === 'object' && config;
  5980.  
  5981.         if (!data) {
  5982.           data = new ScrollSpy(this, _config);
  5983.           $$$1(this).data(DATA_KEY, data);
  5984.         }
  5985.  
  5986.         if (typeof config === 'string') {
  5987.           if (typeof data[config] === 'undefined') {
  5988.             throw new TypeError("No method named \"" + config + "\"");
  5989.           }
  5990.  
  5991.           data[config]();
  5992.         }
  5993.       });
  5994.     };
  5995.  
  5996.     _createClass(ScrollSpy, null, [{
  5997.       key: "VERSION",
  5998.       get: function get() {
  5999.         return VERSION;
  6000.       }
  6001.     }, {
  6002.       key: "Default",
  6003.       get: function get() {
  6004.         return Default;
  6005.       }
  6006.     }]);
  6007.     return ScrollSpy;
  6008.   }();
  6009.   /**
  6010.    * ------------------------------------------------------------------------
  6011.    * Data Api implementation
  6012.    * ------------------------------------------------------------------------
  6013.    */
  6014.  
  6015.  
  6016.   $$$1(window).on(Event.LOAD_DATA_API, function () {
  6017.     var scrollSpys = $$$1.makeArray($$$1(Selector.DATA_SPY));
  6018.  
  6019.     for (var i = scrollSpys.length; i--;) {
  6020.       var $spy = $$$1(scrollSpys[i]);
  6021.  
  6022.       ScrollSpy._jQueryInterface.call($spy, $spy.data());
  6023.     }
  6024.   });
  6025.   /**
  6026.    * ------------------------------------------------------------------------
  6027.    * jQuery
  6028.    * ------------------------------------------------------------------------
  6029.    */
  6030.  
  6031.   $$$1.fn[NAME] = ScrollSpy._jQueryInterface;
  6032.   $$$1.fn[NAME].Constructor = ScrollSpy;
  6033.  
  6034.   $$$1.fn[NAME].noConflict = function () {
  6035.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  6036.     return ScrollSpy._jQueryInterface;
  6037.   };
  6038.  
  6039.   return ScrollSpy;
  6040. }($);
  6041.  
  6042. /**
  6043.  * --------------------------------------------------------------------------
  6044.  * Bootstrap (v4.0.0): tab.js
  6045.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  6046.  * --------------------------------------------------------------------------
  6047.  */
  6048.  
  6049. var Tab = function ($$$1) {
  6050.   /**
  6051.    * ------------------------------------------------------------------------
  6052.    * Constants
  6053.    * ------------------------------------------------------------------------
  6054.    */
  6055.   var NAME = 'tab';
  6056.   var VERSION = '4.0.0';
  6057.   var DATA_KEY = 'bs.tab';
  6058.   var EVENT_KEY = "." + DATA_KEY;
  6059.   var DATA_API_KEY = '.data-api';
  6060.   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
  6061.   var TRANSITION_DURATION = 150;
  6062.   var Event = {
  6063.     HIDE: "hide" + EVENT_KEY,
  6064.     HIDDEN: "hidden" + EVENT_KEY,
  6065.     SHOW: "show" + EVENT_KEY,
  6066.     SHOWN: "shown" + EVENT_KEY,
  6067.     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
  6068.   };
  6069.   var ClassName = {
  6070.     DROPDOWN_MENU: 'dropdown-menu',
  6071.     ACTIVE: 'active',
  6072.     DISABLED: 'disabled',
  6073.     FADE: 'fade',
  6074.     SHOW: 'show'
  6075.   };
  6076.   var Selector = {
  6077.     DROPDOWN: '.dropdown',
  6078.     NAV_LIST_GROUP: '.nav, .list-group',
  6079.     ACTIVE: '.active',
  6080.     ACTIVE_UL: '> li > .active',
  6081.     DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
  6082.     DROPDOWN_TOGGLE: '.dropdown-toggle',
  6083.     DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
  6084.     /**
  6085.      * ------------------------------------------------------------------------
  6086.      * Class Definition
  6087.      * ------------------------------------------------------------------------
  6088.      */
  6089.  
  6090.   };
  6091.  
  6092.   var Tab =
  6093.   /*#__PURE__*/
  6094.   function () {
  6095.     function Tab(element) {
  6096.       this._element = element;
  6097.     } // Getters
  6098.  
  6099.  
  6100.     var _proto = Tab.prototype;
  6101.  
  6102.     // Public
  6103.     _proto.show = function show() {
  6104.       var _this = this;
  6105.  
  6106.       if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
  6107.         return;
  6108.       }
  6109.  
  6110.       var target;
  6111.       var previous;
  6112.       var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0];
  6113.       var selector = Util.getSelectorFromElement(this._element);
  6114.  
  6115.       if (listElement) {
  6116.         var itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE;
  6117.         previous = $$$1.makeArray($$$1(listElement).find(itemSelector));
  6118.         previous = previous[previous.length - 1];
  6119.       }
  6120.  
  6121.       var hideEvent = $$$1.Event(Event.HIDE, {
  6122.         relatedTarget: this._element
  6123.       });
  6124.       var showEvent = $$$1.Event(Event.SHOW, {
  6125.         relatedTarget: previous
  6126.       });
  6127.  
  6128.       if (previous) {
  6129.         $$$1(previous).trigger(hideEvent);
  6130.       }
  6131.  
  6132.       $$$1(this._element).trigger(showEvent);
  6133.  
  6134.       if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
  6135.         return;
  6136.       }
  6137.  
  6138.       if (selector) {
  6139.         target = $$$1(selector)[0];
  6140.       }
  6141.  
  6142.       this._activate(this._element, listElement);
  6143.  
  6144.       var complete = function complete() {
  6145.         var hiddenEvent = $$$1.Event(Event.HIDDEN, {
  6146.           relatedTarget: _this._element
  6147.         });
  6148.         var shownEvent = $$$1.Event(Event.SHOWN, {
  6149.           relatedTarget: previous
  6150.         });
  6151.         $$$1(previous).trigger(hiddenEvent);
  6152.         $$$1(_this._element).trigger(shownEvent);
  6153.       };
  6154.  
  6155.       if (target) {
  6156.         this._activate(target, target.parentNode, complete);
  6157.       } else {
  6158.         complete();
  6159.       }
  6160.     };
  6161.  
  6162.     _proto.dispose = function dispose() {
  6163.       $$$1.removeData(this._element, DATA_KEY);
  6164.       this._element = null;
  6165.     }; // Private
  6166.  
  6167.  
  6168.     _proto._activate = function _activate(element, container, callback) {
  6169.       var _this2 = this;
  6170.  
  6171.       var activeElements;
  6172.  
  6173.       if (container.nodeName === 'UL') {
  6174.         activeElements = $$$1(container).find(Selector.ACTIVE_UL);
  6175.       } else {
  6176.         activeElements = $$$1(container).children(Selector.ACTIVE);
  6177.       }
  6178.  
  6179.       var active = activeElements[0];
  6180.       var isTransitioning = callback && Util.supportsTransitionEnd() && active && $$$1(active).hasClass(ClassName.FADE);
  6181.  
  6182.       var complete = function complete() {
  6183.         return _this2._transitionComplete(element, active, callback);
  6184.       };
  6185.  
  6186.       if (active && isTransitioning) {
  6187.         $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
  6188.       } else {
  6189.         complete();
  6190.       }
  6191.     };
  6192.  
  6193.     _proto._transitionComplete = function _transitionComplete(element, active, callback) {
  6194.       if (active) {
  6195.         $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
  6196.         var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
  6197.  
  6198.         if (dropdownChild) {
  6199.           $$$1(dropdownChild).removeClass(ClassName.ACTIVE);
  6200.         }
  6201.  
  6202.         if (active.getAttribute('role') === 'tab') {
  6203.           active.setAttribute('aria-selected', false);
  6204.         }
  6205.       }
  6206.  
  6207.       $$$1(element).addClass(ClassName.ACTIVE);
  6208.  
  6209.       if (element.getAttribute('role') === 'tab') {
  6210.         element.setAttribute('aria-selected', true);
  6211.       }
  6212.  
  6213.       Util.reflow(element);
  6214.       $$$1(element).addClass(ClassName.SHOW);
  6215.  
  6216.       if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
  6217.         var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0];
  6218.  
  6219.         if (dropdownElement) {
  6220.           $$$1(dropdownElement).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
  6221.         }
  6222.  
  6223.         element.setAttribute('aria-expanded', true);
  6224.       }
  6225.  
  6226.       if (callback) {
  6227.         callback();
  6228.       }
  6229.     }; // Static
  6230.  
  6231.  
  6232.     Tab._jQueryInterface = function _jQueryInterface(config) {
  6233.       return this.each(function () {
  6234.         var $this = $$$1(this);
  6235.         var data = $this.data(DATA_KEY);
  6236.  
  6237.         if (!data) {
  6238.           data = new Tab(this);
  6239.           $this.data(DATA_KEY, data);
  6240.         }
  6241.  
  6242.         if (typeof config === 'string') {
  6243.           if (typeof data[config] === 'undefined') {
  6244.             throw new TypeError("No method named \"" + config + "\"");
  6245.           }
  6246.  
  6247.           data[config]();
  6248.         }
  6249.       });
  6250.     };
  6251.  
  6252.     _createClass(Tab, null, [{
  6253.       key: "VERSION",
  6254.       get: function get() {
  6255.         return VERSION;
  6256.       }
  6257.     }]);
  6258.     return Tab;
  6259.   }();
  6260.   /**
  6261.    * ------------------------------------------------------------------------
  6262.    * Data Api implementation
  6263.    * ------------------------------------------------------------------------
  6264.    */
  6265.  
  6266.  
  6267.   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
  6268.     event.preventDefault();
  6269.  
  6270.     Tab._jQueryInterface.call($$$1(this), 'show');
  6271.   });
  6272.   /**
  6273.    * ------------------------------------------------------------------------
  6274.    * jQuery
  6275.    * ------------------------------------------------------------------------
  6276.    */
  6277.  
  6278.   $$$1.fn[NAME] = Tab._jQueryInterface;
  6279.   $$$1.fn[NAME].Constructor = Tab;
  6280.  
  6281.   $$$1.fn[NAME].noConflict = function () {
  6282.     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
  6283.     return Tab._jQueryInterface;
  6284.   };
  6285.  
  6286.   return Tab;
  6287. }($);
  6288.  
  6289. /**
  6290.  * --------------------------------------------------------------------------
  6291.  * Bootstrap (v4.0.0-alpha.6): index.js
  6292.  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  6293.  * --------------------------------------------------------------------------
  6294.  */
  6295.  
  6296. (function ($$$1) {
  6297.   if (typeof $$$1 === 'undefined') {
  6298.     throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
  6299.   }
  6300.  
  6301.   var version = $$$1.fn.jquery.split(' ')[0].split('.');
  6302.   var minMajor = 1;
  6303.   var ltMajor = 2;
  6304.   var minMinor = 9;
  6305.   var minPatch = 1;
  6306.   var maxMajor = 4;
  6307.  
  6308.   if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
  6309.     throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
  6310.   }
  6311. })($);
  6312.  
  6313. exports.Util = Util;
  6314. exports.Alert = Alert;
  6315. exports.Button = Button;
  6316. exports.Carousel = Carousel;
  6317. exports.Collapse = Collapse;
  6318. exports.Dropdown = Dropdown;
  6319. exports.Modal = Modal;
  6320. exports.Popover = Popover;
  6321. exports.Scrollspy = ScrollSpy;
  6322. exports.Tab = Tab;
  6323. exports.Tooltip = Tooltip;
  6324.  
  6325. Object.defineProperty(exports, '__esModule', { value: true });
  6326.  
  6327. })));
  6328. //# sourceMappingURL=bootstrap.bundle.js.map
  6329.