https://www.musee-saintcloud.fr/themes/musee_stcloud_radix/assets/js/stcloud_radix.script.js?v=11.4.7

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// define getter function for harmony exports
37/******/ 	__webpack_require__.d = function(exports, name, getter) {
38/******/ 		if(!__webpack_require__.o(exports, name)) {
39/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
40/******/ 		}
41/******/ 	};
42/******/
43/******/ 	// define __esModule on exports
44/******/ 	__webpack_require__.r = function(exports) {
45/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
46/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47/******/ 		}
48/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
49/******/ 	};
50/******/
51/******/ 	// create a fake namespace object
52/******/ 	// mode & 1: value is a module id, require it
53/******/ 	// mode & 2: merge all properties of value into the ns
54/******/ 	// mode & 4: return value when already ns object
55/******/ 	// mode & 8|1: behave like require
56/******/ 	__webpack_require__.t = function(value, mode) {
57/******/ 		if(mode & 1) value = __webpack_require__(value);
58/******/ 		if(mode & 8) return value;
59/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
60/******/ 		var ns = Object.create(null);
61/******/ 		__webpack_require__.r(ns);
62/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
64/******/ 		return ns;
65/******/ 	};
66/******/
67/******/ 	// getDefaultExport function for compatibility with non-harmony modules
68/******/ 	__webpack_require__.n = function(module) {
69/******/ 		var getter = module && module.__esModule ?
70/******/ 			function getDefault() { return module['default']; } :
71/******/ 			function getModuleExports() { return module; };
72/******/ 		__webpack_require__.d(getter, 'a', getter);
73/******/ 		return getter;
74/******/ 	};
75/******/
76/******/ 	// Object.prototype.hasOwnProperty.call
77/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78/******/
79/******/ 	// __webpack_public_path__
80/******/ 	__webpack_require__.p = "/";
81/******/
82/******/
83/******/ 	// Load entry module and return exports
84/******/ 	return __webpack_require__(__webpack_require__.s = 0);
85/******/ })
86/************************************************************************/
87/******/ ({
88

966/***/ "./node_modules/bootstrap/dist/js/bootstrap.js":
967/*!*****************************************************!*\
968  !*** ./node_modules/bootstrap/dist/js/bootstrap.js ***!
969  \*****************************************************/
970/*! no static exports found */
971/***/ (function(module, exports, __webpack_require__) {
972
973/*!
974  * Bootstrap v4.3.1 (https://getbootstrap.com/)
975  * Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
976  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
977  */
978(function (global, factory) {
979   true ? factory(exports, __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! popper.js */ "./node_modules/popper.js/dist/esm/popper.js")) :
980  undefined;
981}(this, function (exports, $, Popper) { 'use strict';
982
983  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
984  Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
985
986  function _defineProperties(target, props) {
987    for (var i = 0; i < props.length; i++) {
988      var descriptor = props[i];
989      descriptor.enumerable = descriptor.enumerable || false;
990      descriptor.configurable = true;
991      if ("value" in descriptor) descriptor.writable = true;
992      Object.defineProperty(target, descriptor.key, descriptor);
993    }
994  }
995
996  function _createClass(Constructor, protoProps, staticProps) {
997    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
998    if (staticProps) _defineProperties(Constructor, staticProps);
999    return Constructor;
1000  }
1001
1002  function _defineProperty(obj, key, value) {
1003    if (key in obj) {
1004      Object.defineProperty(obj, key, {
1005        value: value,
1006        enumerable: true,
1007        configurable: true,
1008        writable: true
1009      });
1010    } else {
1011      obj[key] = value;
1012    }
1013
1014    return obj;
1015  }
1016
1017  function _objectSpread(target) {
1018    for (var i = 1; i < arguments.length; i++) {
1019      var source = arguments[i] != null ? arguments[i] : {};
1020      var ownKeys = Object.keys(source);
1021
1022      if (typeof Object.getOwnPropertySymbols === 'function') {
1023        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
1024          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
1025        }));
1026      }
1027
1028      ownKeys.forEach(function (key) {
1029        _defineProperty(target, key, source[key]);
1030      });
1031    }
1032
1033    return target;
1034  }
1035
1036  function _inheritsLoose(subClass, superClass) {
1037    subClass.prototype = Object.create(superClass.prototype);
1038    subClass.prototype.constructor = subClass;
1039    subClass.__proto__ = superClass;
1040  }
1041
1042  /**
1043   * --------------------------------------------------------------------------
1044   * Bootstrap (v4.3.1): util.js
1045   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1046   * --------------------------------------------------------------------------
1047   */
1048  /**
1049   * ------------------------------------------------------------------------
1050   * Private TransitionEnd Helpers
1051   * ------------------------------------------------------------------------
1052   */
1053
1054  var TRANSITION_END = 'transitionend';
1055  var MAX_UID = 1000000;
1056  var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
1057
1058  function toType(obj) {
1059    return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
1060  }
1061
1062  function getSpecialTransitionEndEvent() {
1063    return {
1064      bindType: TRANSITION_END,
1065      delegateType: TRANSITION_END,
1066      handle: function handle(event) {
1067        if ($(event.target).is(this)) {
1068          return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
1069        }
1070
1071        return undefined; // eslint-disable-line no-undefined
1072      }
1073    };
1074  }
1075
1076  function transitionEndEmulator(duration) {
1077    var _this = this;
1078
1079    var called = false;
1080    $(this).one(Util.TRANSITION_END, function () {
1081      called = true;
1082    });
1083    setTimeout(function () {
1084      if (!called) {
1085        Util.triggerTransitionEnd(_this);
1086      }
1087    }, duration);
1088    return this;
1089  }
1090
1091  function setTransitionEndSupport() {
1092    $.fn.emulateTransitionEnd = transitionEndEmulator;
1093    $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
1094  }
1095  /**
1096   * --------------------------------------------------------------------------
1097   * Public Util Api
1098   * --------------------------------------------------------------------------
1099   */
1100
1101
1102  var Util = {
1103    TRANSITION_END: 'bsTransitionEnd',
1104    getUID: function getUID(prefix) {
1105      do {
1106        // eslint-disable-next-line no-bitwise
1107        prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
1108      } while (document.getElementById(prefix));
1109
1110      return prefix;
1111    },
1112    getSelectorFromElement: function getSelectorFromElement(element) {
1113      var selector = element.getAttribute('data-target');
1114
1115      if (!selector || selector === '#') {
1116        var hrefAttr = element.getAttribute('href');
1117        selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : '';
1118      }
1119
1120      try {
1121        return document.querySelector(selector) ? selector : null;
1122      } catch (err) {
1123        return null;
1124      }
1125    },
1126    getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
1127      if (!element) {
1128        return 0;
1129      } // Get transition-duration of the element
1130
1131
1132      var transitionDuration = $(element).css('transition-duration');
1133      var transitionDelay = $(element).css('transition-delay');
1134      var floatTransitionDuration = parseFloat(transitionDuration);
1135      var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
1136
1137      if (!floatTransitionDuration && !floatTransitionDelay) {
1138        return 0;
1139      } // If multiple durations are defined, take the first
1140
1141
1142      transitionDuration = transitionDuration.split(',')[0];
1143      transitionDelay = transitionDelay.split(',')[0];
1144      return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
1145    },
1146    reflow: function reflow(element) {
1147      return element.offsetHeight;
1148    },
1149    triggerTransitionEnd: function triggerTransitionEnd(element) {
1150      $(element).trigger(TRANSITION_END);
1151    },
1152    // TODO: Remove in v5
1153    supportsTransitionEnd: function supportsTransitionEnd() {
1154      return Boolean(TRANSITION_END);
1155    },
1156    isElement: function isElement(obj) {
1157      return (obj[0] || obj).nodeType;
1158    },
1159    typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
1160      for (var property in configTypes) {
1161        if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
1162          var expectedTypes = configTypes[property];
1163          var value = config[property];
1164          var valueType = value && Util.isElement(value) ? 'element' : toType(value);
1165
1166          if (!new RegExp(expectedTypes).test(valueType)) {
1167            throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
1168          }
1169        }
1170      }
1171    },
1172    findShadowRoot: function findShadowRoot(element) {
1173      if (!document.documentElement.attachShadow) {
1174        return null;
1175      } // Can find the shadow root otherwise it'll return the document
1176
1177
1178      if (typeof element.getRootNode === 'function') {
1179        var root = element.getRootNode();
1180        return root instanceof ShadowRoot ? root : null;
1181      }
1182
1183      if (element instanceof ShadowRoot) {
1184        return element;
1185      } // when we don't find a shadow root
1186
1187
1188      if (!element.parentNode) {
1189        return null;
1190      }
1191
1192      return Util.findShadowRoot(element.parentNode);
1193    }
1194  };
1195  setTransitionEndSupport();
1196
1197  /**
1198   * ------------------------------------------------------------------------
1199   * Constants
1200   * ------------------------------------------------------------------------
1201   */
1202
1203  var NAME = 'alert';
1204  var VERSION = '4.3.1';
1205  var DATA_KEY = 'bs.alert';
1206  var EVENT_KEY = "." + DATA_KEY;
1207  var DATA_API_KEY = '.data-api';
1208  var JQUERY_NO_CONFLICT = $.fn[NAME];
1209  var Selector = {
1210    DISMISS: '[data-dismiss="alert"]'
1211  };
1212  var Event = {
1213    CLOSE: "close" + EVENT_KEY,
1214    CLOSED: "closed" + EVENT_KEY,
1215    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
1216  };
1217  var ClassName = {
1218    ALERT: 'alert',
1219    FADE: 'fade',
1220    SHOW: 'show'
1221    /**
1222     * ------------------------------------------------------------------------
1223     * Class Definition
1224     * ------------------------------------------------------------------------
1225     */
1226
1227  };
1228
1229  var Alert =
1230  /*#__PURE__*/
1231  function () {
1232    function Alert(element) {
1233      this._element = element;
1234    } // Getters
1235
1236
1237    var _proto = Alert.prototype;
1238
1239    // Public
1240    _proto.close = function close(element) {
1241      var rootElement = this._element;
1242
1243      if (element) {
1244        rootElement = this._getRootElement(element);
1245      }
1246
1247      var customEvent = this._triggerCloseEvent(rootElement);
1248
1249      if (customEvent.isDefaultPrevented()) {
1250        return;
1251      }
1252
1253      this._removeElement(rootElement);
1254    };
1255
1256    _proto.dispose = function dispose() {
1257      $.removeData(this._element, DATA_KEY);
1258      this._element = null;
1259    } // Private
1260    ;
1261
1262    _proto._getRootElement = function _getRootElement(element) {
1263      var selector = Util.getSelectorFromElement(element);
1264      var parent = false;
1265
1266      if (selector) {
1267        parent = document.querySelector(selector);
1268      }
1269
1270      if (!parent) {
1271        parent = $(element).closest("." + ClassName.ALERT)[0];
1272      }
1273
1274      return parent;
1275    };
1276
1277    _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
1278      var closeEvent = $.Event(Event.CLOSE);
1279      $(element).trigger(closeEvent);
1280      return closeEvent;
1281    };
1282
1283    _proto._removeElement = function _removeElement(element) {
1284      var _this = this;
1285
1286      $(element).removeClass(ClassName.SHOW);
1287
1288      if (!$(element).hasClass(ClassName.FADE)) {
1289        this._destroyElement(element);
1290
1291        return;
1292      }
1293
1294      var transitionDuration = Util.getTransitionDurationFromElement(element);
1295      $(element).one(Util.TRANSITION_END, function (event) {
1296        return _this._destroyElement(element, event);
1297      }).emulateTransitionEnd(transitionDuration);
1298    };
1299
1300    _proto._destroyElement = function _destroyElement(element) {
1301      $(element).detach().trigger(Event.CLOSED).remove();
1302    } // Static
1303    ;
1304
1305    Alert._jQueryInterface = function _jQueryInterface(config) {
1306      return this.each(function () {
1307        var $element = $(this);
1308        var data = $element.data(DATA_KEY);
1309
1310        if (!data) {
1311          data = new Alert(this);
1312          $element.data(DATA_KEY, data);
1313        }
1314
1315        if (config === 'close') {
1316          data[config](this);
1317        }
1318      });
1319    };
1320
1321    Alert._handleDismiss = function _handleDismiss(alertInstance) {
1322      return function (event) {
1323        if (event) {
1324          event.preventDefault();
1325        }
1326
1327        alertInstance.close(this);
1328      };
1329    };
1330
1331    _createClass(Alert, null, [{
1332      key: "VERSION",
1333      get: function get() {
1334        return VERSION;
1335      }
1336    }]);
1337
1338    return Alert;
1339  }();
1340  /**
1341   * ------------------------------------------------------------------------
1342   * Data Api implementation
1343   * ------------------------------------------------------------------------
1344   */
1345
1346
1347  $(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
1348  /**
1349   * ------------------------------------------------------------------------
1350   * jQuery
1351   * ------------------------------------------------------------------------
1352   */
1353
1354  $.fn[NAME] = Alert._jQueryInterface;
1355  $.fn[NAME].Constructor = Alert;
1356
1357  $.fn[NAME].noConflict = function () {
1358    $.fn[NAME] = JQUERY_NO_CONFLICT;
1359    return Alert._jQueryInterface;
1360  };
1361
1362  /**
1363   * ------------------------------------------------------------------------
1364   * Constants
1365   * ------------------------------------------------------------------------
1366   */
1367
1368  var NAME$1 = 'button';
1369  var VERSION$1 = '4.3.1';
1370  var DATA_KEY$1 = 'bs.button';
1371  var EVENT_KEY$1 = "." + DATA_KEY$1;
1372  var DATA_API_KEY$1 = '.data-api';
1373  var JQUERY_NO_CONFLICT$1 = $.fn[NAME$1];
1374  var ClassName$1 = {
1375    ACTIVE: 'active',
1376    BUTTON: 'btn',
1377    FOCUS: 'focus'
1378  };
1379  var Selector$1 = {
1380    DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
1381    DATA_TOGGLE: '[data-toggle="buttons"]',
1382    INPUT: 'input:not([type="hidden"])',
1383    ACTIVE: '.active',
1384    BUTTON: '.btn'
1385  };
1386  var Event$1 = {
1387    CLICK_DATA_API: "click" + EVENT_KEY$1 + DATA_API_KEY$1,
1388    FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1)
1389    /**
1390     * ------------------------------------------------------------------------
1391     * Class Definition
1392     * ------------------------------------------------------------------------
1393     */
1394
1395  };
1396
1397  var Button =
1398  /*#__PURE__*/
1399  function () {
1400    function Button(element) {
1401      this._element = element;
1402    } // Getters
1403
1404
1405    var _proto = Button.prototype;
1406
1407    // Public
1408    _proto.toggle = function toggle() {
1409      var triggerChangeEvent = true;
1410      var addAriaPressed = true;
1411      var rootElement = $(this._element).closest(Selector$1.DATA_TOGGLE)[0];
1412
1413      if (rootElement) {
1414        var input = this._element.querySelector(Selector$1.INPUT);
1415
1416        if (input) {
1417          if (input.type === 'radio') {
1418            if (input.checked && this._element.classList.contains(ClassName$1.ACTIVE)) {
1419              triggerChangeEvent = false;
1420            } else {
1421              var activeElement = rootElement.querySelector(Selector$1.ACTIVE);
1422
1423              if (activeElement) {
1424                $(activeElement).removeClass(ClassName$1.ACTIVE);
1425              }
1426            }
1427          }
1428
1429          if (triggerChangeEvent) {
1430            if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
1431              return;
1432            }
1433
1434            input.checked = !this._element.classList.contains(ClassName$1.ACTIVE);
1435            $(input).trigger('change');
1436          }
1437
1438          input.focus();
1439          addAriaPressed = false;
1440        }
1441      }
1442
1443      if (addAriaPressed) {
1444        this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName$1.ACTIVE));
1445      }
1446
1447      if (triggerChangeEvent) {
1448        $(this._element).toggleClass(ClassName$1.ACTIVE);
1449      }
1450    };
1451
1452    _proto.dispose = function dispose() {
1453      $.removeData(this._element, DATA_KEY$1);
1454      this._element = null;
1455    } // Static
1456    ;
1457
1458    Button._jQueryInterface = function _jQueryInterface(config) {
1459      return this.each(function () {
1460        var data = $(this).data(DATA_KEY$1);
1461
1462        if (!data) {
1463          data = new Button(this);
1464          $(this).data(DATA_KEY$1, data);
1465        }
1466
1467        if (config === 'toggle') {
1468          data[config]();
1469        }
1470      });
1471    };
1472
1473    _createClass(Button, null, [{
1474      key: "VERSION",
1475      get: function get() {
1476        return VERSION$1;
1477      }
1478    }]);
1479
1480    return Button;
1481  }();
1482  /**
1483   * ------------------------------------------------------------------------
1484   * Data Api implementation
1485   * ------------------------------------------------------------------------
1486   */
1487
1488
1489  $(document).on(Event$1.CLICK_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
1490    event.preventDefault();
1491    var button = event.target;
1492
1493    if (!$(button).hasClass(ClassName$1.BUTTON)) {
1494      button = $(button).closest(Selector$1.BUTTON);
1495    }
1496
1497    Button._jQueryInterface.call($(button), 'toggle');
1498  }).on(Event$1.FOCUS_BLUR_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
1499    var button = $(event.target).closest(Selector$1.BUTTON)[0];
1500    $(button).toggleClass(ClassName$1.FOCUS, /^focus(in)?$/.test(event.type));
1501  });
1502  /**
1503   * ------------------------------------------------------------------------
1504   * jQuery
1505   * ------------------------------------------------------------------------
1506   */
1507
1508  $.fn[NAME$1] = Button._jQueryInterface;
1509  $.fn[NAME$1].Constructor = Button;
1510
1511  $.fn[NAME$1].noConflict = function () {
1512    $.fn[NAME$1] = JQUERY_NO_CONFLICT$1;
1513    return Button._jQueryInterface;
1514  };
1515
1516  /**
1517   * ------------------------------------------------------------------------
1518   * Constants
1519   * ------------------------------------------------------------------------
1520   */
1521
1522  var NAME$2 = 'carousel';
1523  var VERSION$2 = '4.3.1';
1524  var DATA_KEY$2 = 'bs.carousel';
1525  var EVENT_KEY$2 = "." + DATA_KEY$2;
1526  var DATA_API_KEY$2 = '.data-api';
1527  var JQUERY_NO_CONFLICT$2 = $.fn[NAME$2];
1528  var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
1529
1530  var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
1531
1532  var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
1533
1534  var SWIPE_THRESHOLD = 40;
1535  var Default = {
1536    interval: 5000,
1537    keyboard: true,
1538    slide: false,
1539    pause: 'hover',
1540    wrap: true,
1541    touch: true
1542  };
1543  var DefaultType = {
1544    interval: '(number|boolean)',
1545    keyboard: 'boolean',
1546    slide: '(boolean|string)',
1547    pause: '(string|boolean)',
1548    wrap: 'boolean',
1549    touch: 'boolean'
1550  };
1551  var Direction = {
1552    NEXT: 'next',
1553    PREV: 'prev',
1554    LEFT: 'left',
1555    RIGHT: 'right'
1556  };
1557  var Event$2 = {
1558    SLIDE: "slide" + EVENT_KEY$2,
1559    SLID: "slid" + EVENT_KEY$2,
1560    KEYDOWN: "keydown" + EVENT_KEY$2,
1561    MOUSEENTER: "mouseenter" + EVENT_KEY$2,
1562    MOUSELEAVE: "mouseleave" + EVENT_KEY$2,
1563    TOUCHSTART: "touchstart" + EVENT_KEY$2,
1564    TOUCHMOVE: "touchmove" + EVENT_KEY$2,
1565    TOUCHEND: "touchend" + EVENT_KEY$2,
1566    POINTERDOWN: "pointerdown" + EVENT_KEY$2,
1567    POINTERUP: "pointerup" + EVENT_KEY$2,
1568    DRAG_START: "dragstart" + EVENT_KEY$2,
1569    LOAD_DATA_API: "load" + EVENT_KEY$2 + DATA_API_KEY$2,
1570    CLICK_DATA_API: "click" + EVENT_KEY$2 + DATA_API_KEY$2
1571  };
1572  var ClassName$2 = {
1573    CAROUSEL: 'carousel',
1574    ACTIVE: 'active',
1575    SLIDE: 'slide',
1576    RIGHT: 'carousel-item-right',
1577    LEFT: 'carousel-item-left',
1578    NEXT: 'carousel-item-next',
1579    PREV: 'carousel-item-prev',
1580    ITEM: 'carousel-item',
1581    POINTER_EVENT: 'pointer-event'
1582  };
1583  var Selector$2 = {
1584    ACTIVE: '.active',
1585    ACTIVE_ITEM: '.active.carousel-item',
1586    ITEM: '.carousel-item',
1587    ITEM_IMG: '.carousel-item img',
1588    NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
1589    INDICATORS: '.carousel-indicators',
1590    DATA_SLIDE: '[data-slide], [data-slide-to]',
1591    DATA_RIDE: '[data-ride="carousel"]'
1592  };
1593  var PointerType = {
1594    TOUCH: 'touch',
1595    PEN: 'pen'
1596    /**
1597     * ------------------------------------------------------------------------
1598     * Class Definition
1599     * ------------------------------------------------------------------------
1600     */
1601
1602  };
1603
1604  var Carousel =
1605  /*#__PURE__*/
1606  function () {
1607    function Carousel(element, config) {
1608      this._items = null;
1609      this._interval = null;
1610      this._activeElement = null;
1611      this._isPaused = false;
1612      this._isSliding = false;
1613      this.touchTimeout = null;
1614      this.touchStartX = 0;
1615      this.touchDeltaX = 0;
1616      this._config = this._getConfig(config);
1617      this._element = element;
1618      this._indicatorsElement = this._element.querySelector(Selector$2.INDICATORS);
1619      this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
1620      this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent);
1621
1622      this._addEventListeners();
1623    } // Getters
1624
1625
1626    var _proto = Carousel.prototype;
1627
1628    // Public
1629    _proto.next = function next() {
1630      if (!this._isSliding) {
1631        this._slide(Direction.NEXT);
1632      }
1633    };
1634
1635    _proto.nextWhenVisible = function nextWhenVisible() {
1636      // Don't call next when the page isn't visible
1637      // or the carousel or its parent isn't visible
1638      if (!document.hidden && $(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden') {
1639        this.next();
1640      }
1641    };
1642
1643    _proto.prev = function prev() {
1644      if (!this._isSliding) {
1645        this._slide(Direction.PREV);
1646      }
1647    };
1648
1649    _proto.pause = function pause(event) {
1650      if (!event) {
1651        this._isPaused = true;
1652      }
1653
1654      if (this._element.querySelector(Selector$2.NEXT_PREV)) {
1655        Util.triggerTransitionEnd(this._element);
1656        this.cycle(true);
1657      }
1658
1659      clearInterval(this._interval);
1660      this._interval = null;
1661    };
1662
1663    _proto.cycle = function cycle(event) {
1664      if (!event) {
1665        this._isPaused = false;
1666      }
1667
1668      if (this._interval) {
1669        clearInterval(this._interval);
1670        this._interval = null;
1671      }
1672
1673      if (this._config.interval && !this._isPaused) {
1674        this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
1675      }
1676    };
1677
1678    _proto.to = function to(index) {
1679      var _this = this;
1680
1681      this._activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);
1682
1683      var activeIndex = this._getItemIndex(this._activeElement);
1684
1685      if (index > this._items.length - 1 || index < 0) {
1686        return;
1687      }
1688
1689      if (this._isSliding) {
1690        $(this._element).one(Event$2.SLID, function () {
1691          return _this.to(index);
1692        });
1693        return;
1694      }
1695
1696      if (activeIndex === index) {
1697        this.pause();
1698        this.cycle();
1699        return;
1700      }
1701
1702      var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
1703
1704      this._slide(direction, this._items[index]);
1705    };
1706
1707    _proto.dispose = function dispose() {
1708      $(this._element).off(EVENT_KEY$2);
1709      $.removeData(this._element, DATA_KEY$2);
1710      this._items = null;
1711      this._config = null;
1712      this._element = null;
1713      this._interval = null;
1714      this._isPaused = null;
1715      this._isSliding = null;
1716      this._activeElement = null;
1717      this._indicatorsElement = null;
1718    } // Private
1719    ;
1720
1721    _proto._getConfig = function _getConfig(config) {
1722      config = _objectSpread({}, Default, config);
1723      Util.typeCheckConfig(NAME$2, config, DefaultType);
1724      return config;
1725    };
1726
1727    _proto._handleSwipe = function _handleSwipe() {
1728      var absDeltax = Math.abs(this.touchDeltaX);
1729
1730      if (absDeltax <= SWIPE_THRESHOLD) {
1731        return;
1732      }
1733
1734      var direction = absDeltax / this.touchDeltaX; // swipe left
1735
1736      if (direction > 0) {
1737        this.prev();
1738      } // swipe right
1739
1740
1741      if (direction < 0) {
1742        this.next();
1743      }
1744    };
1745
1746    _proto._addEventListeners = function _addEventListeners() {
1747      var _this2 = this;
1748
1749      if (this._config.keyboard) {
1750        $(this._element).on(Event$2.KEYDOWN, function (event) {
1751          return _this2._keydown(event);
1752        });
1753      }
1754
1755      if (this._config.pause === 'hover') {
1756        $(this._element).on(Event$2.MOUSEENTER, function (event) {
1757          return _this2.pause(event);
1758        }).on(Event$2.MOUSELEAVE, function (event) {
1759          return _this2.cycle(event);
1760        });
1761      }
1762
1763      if (this._config.touch) {
1764        this._addTouchEventListeners();
1765      }
1766    };
1767
1768    _proto._addTouchEventListeners = function _addTouchEventListeners() {
1769      var _this3 = this;
1770
1771      if (!this._touchSupported) {
1772        return;
1773      }
1774
1775      var start = function start(event) {
1776        if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
1777          _this3.touchStartX = event.originalEvent.clientX;
1778        } else if (!_this3._pointerEvent) {
1779          _this3.touchStartX = event.originalEvent.touches[0].clientX;
1780        }
1781      };
1782
1783      var move = function move(event) {
1784        // ensure swiping with one touch and not pinching
1785        if (event.originalEvent.touches && event.originalEvent.touches.length > 1) {
1786          _this3.touchDeltaX = 0;
1787        } else {
1788          _this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX;
1789        }
1790      };
1791
1792      var end = function end(event) {
1793        if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
1794          _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX;
1795        }
1796
1797        _this3._handleSwipe();
1798
1799        if (_this3._config.pause === 'hover') {
1800          // If it's a touch-enabled device, mouseenter/leave are fired as
1801          // part of the mouse compatibility events on first tap - the carousel
1802          // would stop cycling until user tapped out of it;
1803          // here, we listen for touchend, explicitly pause the carousel
1804          // (as if it's the second time we tap on it, mouseenter compat event
1805          // is NOT fired) and after a timeout (to allow for mouse compatibility
1806          // events to fire) we explicitly restart cycling
1807          _this3.pause();
1808
1809          if (_this3.touchTimeout) {
1810            clearTimeout(_this3.touchTimeout);
1811          }
1812
1813          _this3.touchTimeout = setTimeout(function (event) {
1814            return _this3.cycle(event);
1815          }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval);
1816        }
1817      };
1818
1819      $(this._element.querySelectorAll(Selector$2.ITEM_IMG)).on(Event$2.DRAG_START, function (e) {
1820        return e.preventDefault();
1821      });
1822
1823      if (this._pointerEvent) {
1824        $(this._element).on(Event$2.POINTERDOWN, function (event) {
1825          return start(event);
1826        });
1827        $(this._element).on(Event$2.POINTERUP, function (event) {
1828          return end(event);
1829        });
1830
1831        this._element.classList.add(ClassName$2.POINTER_EVENT);
1832      } else {
1833        $(this._element).on(Event$2.TOUCHSTART, function (event) {
1834          return start(event);
1835        });
1836        $(this._element).on(Event$2.TOUCHMOVE, function (event) {
1837          return move(event);
1838        });
1839        $(this._element).on(Event$2.TOUCHEND, function (event) {
1840          return end(event);
1841        });
1842      }
1843    };
1844
1845    _proto._keydown = function _keydown(event) {
1846      if (/input|textarea/i.test(event.target.tagName)) {
1847        return;
1848      }
1849
1850      switch (event.which) {
1851        case ARROW_LEFT_KEYCODE:
1852          event.preventDefault();
1853          this.prev();
1854          break;
1855
1856        case ARROW_RIGHT_KEYCODE:
1857          event.preventDefault();
1858          this.next();
1859          break;
1860
1861        default:
1862      }
1863    };
1864
1865    _proto._getItemIndex = function _getItemIndex(element) {
1866      this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector$2.ITEM)) : [];
1867      return this._items.indexOf(element);
1868    };
1869
1870    _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
1871      var isNextDirection = direction === Direction.NEXT;
1872      var isPrevDirection = direction === Direction.PREV;
1873
1874      var activeIndex = this._getItemIndex(activeElement);
1875
1876      var lastItemIndex = this._items.length - 1;
1877      var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
1878
1879      if (isGoingToWrap && !this._config.wrap) {
1880        return activeElement;
1881      }
1882
1883      var delta = direction === Direction.PREV ? -1 : 1;
1884      var itemIndex = (activeIndex + delta) % this._items.length;
1885      return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
1886    };
1887
1888    _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
1889      var targetIndex = this._getItemIndex(relatedTarget);
1890
1891      var fromIndex = this._getItemIndex(this._element.querySelector(Selector$2.ACTIVE_ITEM));
1892
1893      var slideEvent = $.Event(Event$2.SLIDE, {
1894        relatedTarget: relatedTarget,
1895        direction: eventDirectionName,
1896        from: fromIndex,
1897        to: targetIndex
1898      });
1899      $(this._element).trigger(slideEvent);
1900      return slideEvent;
1901    };
1902
1903    _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
1904      if (this._indicatorsElement) {
1905        var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector$2.ACTIVE));
1906        $(indicators).removeClass(ClassName$2.ACTIVE);
1907
1908        var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
1909
1910        if (nextIndicator) {
1911          $(nextIndicator).addClass(ClassName$2.ACTIVE);
1912        }
1913      }
1914    };
1915
1916    _proto._slide = function _slide(direction, element) {
1917      var _this4 = this;
1918
1919      var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);
1920
1921      var activeElementIndex = this._getItemIndex(activeElement);
1922
1923      var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
1924
1925      var nextElementIndex = this._getItemIndex(nextElement);
1926
1927      var isCycling = Boolean(this._interval);
1928      var directionalClassName;
1929      var orderClassName;
1930      var eventDirectionName;
1931
1932      if (direction === Direction.NEXT) {
1933        directionalClassName = ClassName$2.LEFT;
1934        orderClassName = ClassName$2.NEXT;
1935        eventDirectionName = Direction.LEFT;
1936      } else {
1937        directionalClassName = ClassName$2.RIGHT;
1938        orderClassName = ClassName$2.PREV;
1939        eventDirectionName = Direction.RIGHT;
1940      }
1941
1942      if (nextElement && $(nextElement).hasClass(ClassName$2.ACTIVE)) {
1943        this._isSliding = false;
1944        return;
1945      }
1946
1947      var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
1948
1949      if (slideEvent.isDefaultPrevented()) {
1950        return;
1951      }
1952
1953      if (!activeElement || !nextElement) {
1954        // Some weirdness is happening, so we bail
1955        return;
1956      }
1957
1958      this._isSliding = true;
1959
1960      if (isCycling) {
1961        this.pause();
1962      }
1963
1964      this._setActiveIndicatorElement(nextElement);
1965
1966      var slidEvent = $.Event(Event$2.SLID, {
1967        relatedTarget: nextElement,
1968        direction: eventDirectionName,
1969        from: activeElementIndex,
1970        to: nextElementIndex
1971      });
1972
1973      if ($(this._element).hasClass(ClassName$2.SLIDE)) {
1974        $(nextElement).addClass(orderClassName);
1975        Util.reflow(nextElement);
1976        $(activeElement).addClass(directionalClassName);
1977        $(nextElement).addClass(directionalClassName);
1978        var nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10);
1979
1980        if (nextElementInterval) {
1981          this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
1982          this._config.interval = nextElementInterval;
1983        } else {
1984          this._config.interval = this._config.defaultInterval || this._config.interval;
1985        }
1986
1987        var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
1988        $(activeElement).one(Util.TRANSITION_END, function () {
1989          $(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName$2.ACTIVE);
1990          $(activeElement).removeClass(ClassName$2.ACTIVE + " " + orderClassName + " " + directionalClassName);
1991          _this4._isSliding = false;
1992          setTimeout(function () {
1993            return $(_this4._element).trigger(slidEvent);
1994          }, 0);
1995        }).emulateTransitionEnd(transitionDuration);
1996      } else {
1997        $(activeElement).removeClass(ClassName$2.ACTIVE);
1998        $(nextElement).addClass(ClassName$2.ACTIVE);
1999        this._isSliding = false;
2000        $(this._element).trigger(slidEvent);
2001      }
2002
2003      if (isCycling) {
2004        this.cycle();
2005      }
2006    } // Static
2007    ;
2008
2009    Carousel._jQueryInterface = function _jQueryInterface(config) {
2010      return this.each(function () {
2011        var data = $(this).data(DATA_KEY$2);
2012
2013        var _config = _objectSpread({}, Default, $(this).data());
2014
2015        if (typeof config === 'object') {
2016          _config = _objectSpread({}, _config, config);
2017        }
2018
2019        var action = typeof config === 'string' ? config : _config.slide;
2020
2021        if (!data) {
2022          data = new Carousel(this, _config);
2023          $(this).data(DATA_KEY$2, data);
2024        }
2025
2026        if (typeof config === 'number') {
2027          data.to(config);
2028        } else if (typeof action === 'string') {
2029          if (typeof data[action] === 'undefined') {
2030            throw new TypeError("No method named \"" + action + "\"");
2031          }
2032
2033          data[action]();
2034        } else if (_config.interval && _config.ride) {
2035          data.pause();
2036          data.cycle();
2037        }
2038      });
2039    };
2040
2041    Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
2042      var selector = Util.getSelectorFromElement(this);
2043
2044      if (!selector) {
2045        return;
2046      }
2047
2048      var target = $(selector)[0];
2049
2050      if (!target || !$(target).hasClass(ClassName$2.CAROUSEL)) {
2051        return;
2052      }
2053
2054      var config = _objectSpread({}, $(target).data(), $(this).data());
2055
2056      var slideIndex = this.getAttribute('data-slide-to');
2057
2058      if (slideIndex) {
2059        config.interval = false;
2060      }
2061
2062      Carousel._jQueryInterface.call($(target), config);
2063
2064      if (slideIndex) {
2065        $(target).data(DATA_KEY$2).to(slideIndex);
2066      }
2067
2068      event.preventDefault();
2069    };
2070
2071    _createClass(Carousel, null, [{
2072      key: "VERSION",
2073      get: function get() {
2074        return VERSION$2;
2075      }
2076    }, {
2077      key: "Default",
2078      get: function get() {
2079        return Default;
2080      }
2081    }]);
2082
2083    return Carousel;
2084  }();
2085  /**
2086   * ------------------------------------------------------------------------
2087   * Data Api implementation
2088   * ------------------------------------------------------------------------
2089   */
2090
2091
2092  $(document).on(Event$2.CLICK_DATA_API, Selector$2.DATA_SLIDE, Carousel._dataApiClickHandler);
2093  $(window).on(Event$2.LOAD_DATA_API, function () {
2094    var carousels = [].slice.call(document.querySelectorAll(Selector$2.DATA_RIDE));
2095
2096    for (var i = 0, len = carousels.length; i < len; i++) {
2097      var $carousel = $(carousels[i]);
2098
2099      Carousel._jQueryInterface.call($carousel, $carousel.data());
2100    }
2101  });
2102  /**
2103   * ------------------------------------------------------------------------
2104   * jQuery
2105   * ------------------------------------------------------------------------
2106   */
2107
2108  $.fn[NAME$2] = Carousel._jQueryInterface;
2109  $.fn[NAME$2].Constructor = Carousel;
2110
2111  $.fn[NAME$2].noConflict = function () {
2112    $.fn[NAME$2] = JQUERY_NO_CONFLICT$2;
2113    return Carousel._jQueryInterface;
2114  };
2115
2116  /**
2117   * ------------------------------------------------------------------------
2118   * Constants
2119   * ------------------------------------------------------------------------
2120   */
2121
2122  var NAME$3 = 'collapse';
2123  var VERSION$3 = '4.3.1';
2124  var DATA_KEY$3 = 'bs.collapse';
2125  var EVENT_KEY$3 = "." + DATA_KEY$3;
2126  var DATA_API_KEY$3 = '.data-api';
2127  var JQUERY_NO_CONFLICT$3 = $.fn[NAME$3];
2128  var Default$1 = {
2129    toggle: true,
2130    parent: ''
2131  };
2132  var DefaultType$1 = {
2133    toggle: 'boolean',
2134    parent: '(string|element)'
2135  };
2136  var Event$3 = {
2137    SHOW: "show" + EVENT_KEY$3,
2138    SHOWN: "shown" + EVENT_KEY$3,
2139    HIDE: "hide" + EVENT_KEY$3,
2140    HIDDEN: "hidden" + EVENT_KEY$3,
2141    CLICK_DATA_API: "click" + EVENT_KEY$3 + DATA_API_KEY$3
2142  };
2143  var ClassName$3 = {
2144    SHOW: 'show',
2145    COLLAPSE: 'collapse',
2146    COLLAPSING: 'collapsing',
2147    COLLAPSED: 'collapsed'
2148  };
2149  var Dimension = {
2150    WIDTH: 'width',
2151    HEIGHT: 'height'
2152  };
2153  var Selector$3 = {
2154    ACTIVES: '.show, .collapsing',
2155    DATA_TOGGLE: '[data-toggle="collapse"]'
2156    /**
2157     * ------------------------------------------------------------------------
2158     * Class Definition
2159     * ------------------------------------------------------------------------
2160     */
2161
2162  };
2163
2164  var Collapse =
2165  /*#__PURE__*/
2166  function () {
2167    function Collapse(element, config) {
2168      this._isTransitioning = false;
2169      this._element = element;
2170      this._config = this._getConfig(config);
2171      this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
2172      var toggleList = [].slice.call(document.querySelectorAll(Selector$3.DATA_TOGGLE));
2173
2174      for (var i = 0, len = toggleList.length; i < len; i++) {
2175        var elem = toggleList[i];
2176        var selector = Util.getSelectorFromElement(elem);
2177        var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) {
2178          return foundElem === element;
2179        });
2180
2181        if (selector !== null && filterElement.length > 0) {
2182          this._selector = selector;
2183
2184          this._triggerArray.push(elem);
2185        }
2186      }
2187
2188      this._parent = this._config.parent ? this._getParent() : null;
2189
2190      if (!this._config.parent) {
2191        this._addAriaAndCollapsedClass(this._element, this._triggerArray);
2192      }
2193
2194      if (this._config.toggle) {
2195        this.toggle();
2196      }
2197    } // Getters
2198
2199
2200    var _proto = Collapse.prototype;
2201
2202    // Public
2203    _proto.toggle = function toggle() {
2204      if ($(this._element).hasClass(ClassName$3.SHOW)) {
2205        this.hide();
2206      } else {
2207        this.show();
2208      }
2209    };
2210
2211    _proto.show = function show() {
2212      var _this = this;
2213
2214      if (this._isTransitioning || $(this._element).hasClass(ClassName$3.SHOW)) {
2215        return;
2216      }
2217
2218      var actives;
2219      var activesData;
2220
2221      if (this._parent) {
2222        actives = [].slice.call(this._parent.querySelectorAll(Selector$3.ACTIVES)).filter(function (elem) {
2223          if (typeof _this._config.parent === 'string') {
2224            return elem.getAttribute('data-parent') === _this._config.parent;
2225          }
2226
2227          return elem.classList.contains(ClassName$3.COLLAPSE);
2228        });
2229
2230        if (actives.length === 0) {
2231          actives = null;
2232        }
2233      }
2234
2235      if (actives) {
2236        activesData = $(actives).not(this._selector).data(DATA_KEY$3);
2237
2238        if (activesData && activesData._isTransitioning) {
2239          return;
2240        }
2241      }
2242
2243      var startEvent = $.Event(Event$3.SHOW);
2244      $(this._element).trigger(startEvent);
2245
2246      if (startEvent.isDefaultPrevented()) {
2247        return;
2248      }
2249
2250      if (actives) {
2251        Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide');
2252
2253        if (!activesData) {
2254          $(actives).data(DATA_KEY$3, null);
2255        }
2256      }
2257
2258      var dimension = this._getDimension();
2259
2260      $(this._element).removeClass(ClassName$3.COLLAPSE).addClass(ClassName$3.COLLAPSING);
2261      this._element.style[dimension] = 0;
2262
2263      if (this._triggerArray.length) {
2264        $(this._triggerArray).removeClass(ClassName$3.COLLAPSED).attr('aria-expanded', true);
2265      }
2266
2267      this.setTransitioning(true);
2268
2269      var complete = function complete() {
2270        $(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW);
2271        _this._element.style[dimension] = '';
2272
2273        _this.setTransitioning(false);
2274
2275        $(_this._element).trigger(Event$3.SHOWN);
2276      };
2277
2278      var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
2279      var scrollSize = "scroll" + capitalizedDimension;
2280      var transitionDuration = Util.getTransitionDurationFromElement(this._element);
2281      $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
2282      this._element.style[dimension] = this._element[scrollSize] + "px";
2283    };
2284
2285    _proto.hide = function hide() {
2286      var _this2 = this;
2287
2288      if (this._isTransitioning || !$(this._element).hasClass(ClassName$3.SHOW)) {
2289        return;
2290      }
2291
2292      var startEvent = $.Event(Event$3.HIDE);
2293      $(this._element).trigger(startEvent);
2294
2295      if (startEvent.isDefaultPrevented()) {
2296        return;
2297      }
2298
2299      var dimension = this._getDimension();
2300
2301      this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
2302      Util.reflow(this._element);
2303      $(this._element).addClass(ClassName$3.COLLAPSING).removeClass(ClassName$3.COLLAPSE).removeClass(ClassName$3.SHOW);
2304      var triggerArrayLength = this._triggerArray.length;
2305
2306      if (triggerArrayLength > 0) {
2307        for (var i = 0; i < triggerArrayLength; i++) {
2308          var trigger = this._triggerArray[i];
2309          var selector = Util.getSelectorFromElement(trigger);
2310
2311          if (selector !== null) {
2312            var $elem = $([].slice.call(document.querySelectorAll(selector)));
2313
2314            if (!$elem.hasClass(ClassName$3.SHOW)) {
2315              $(trigger).addClass(ClassName$3.COLLAPSED).attr('aria-expanded', false);
2316            }
2317          }
2318        }
2319      }
2320
2321      this.setTransitioning(true);
2322
2323      var complete = function complete() {
2324        _this2.setTransitioning(false);
2325
2326        $(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN);
2327      };
2328
2329      this._element.style[dimension] = '';
2330      var transitionDuration = Util.getTransitionDurationFromElement(this._element);
2331      $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
2332    };
2333
2334    _proto.setTransitioning = function setTransitioning(isTransitioning) {
2335      this._isTransitioning = isTransitioning;
2336    };
2337
2338    _proto.dispose = function dispose() {
2339      $.removeData(this._element, DATA_KEY$3);
2340      this._config = null;
2341      this._parent = null;
2342      this._element = null;
2343      this._triggerArray = null;
2344      this._isTransitioning = null;
2345    } // Private
2346    ;
2347
2348    _proto._getConfig = function _getConfig(config) {
2349      config = _objectSpread({}, Default$1, config);
2350      config.toggle = Boolean(config.toggle); // Coerce string values
2351
2352      Util.typeCheckConfig(NAME$3, config, DefaultType$1);
2353      return config;
2354    };
2355
2356    _proto._getDimension = function _getDimension() {
2357      var hasWidth = $(this._element).hasClass(Dimension.WIDTH);
2358      return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
2359    };
2360
2361    _proto._getParent = function _getParent() {
2362      var _this3 = this;
2363
2364      var parent;
2365
2366      if (Util.isElement(this._config.parent)) {
2367        parent = this._config.parent; // It's a jQuery object
2368
2369        if (typeof this._config.parent.jquery !== 'undefined') {
2370          parent = this._config.parent[0];
2371        }
2372      } else {
2373        parent = document.querySelector(this._config.parent);
2374      }
2375
2376      var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
2377      var children = [].slice.call(parent.querySelectorAll(selector));
2378      $(children).each(function (i, element) {
2379        _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
2380      });
2381      return parent;
2382    };
2383
2384    _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
2385      var isOpen = $(element).hasClass(ClassName$3.SHOW);
2386
2387      if (triggerArray.length) {
2388        $(triggerArray).toggleClass(ClassName$3.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
2389      }
2390    } // Static
2391    ;
2392
2393    Collapse._getTargetFromElement = function _getTargetFromElement(element) {
2394      var selector = Util.getSelectorFromElement(element);
2395      return selector ? document.querySelector(selector) : null;
2396    };
2397
2398    Collapse._jQueryInterface = function _jQueryInterface(config) {
2399      return this.each(function () {
2400        var $this = $(this);
2401        var data = $this.data(DATA_KEY$3);
2402
2403        var _config = _objectSpread({}, Default$1, $this.data(), typeof config === 'object' && config ? config : {});
2404
2405        if (!data && _config.toggle && /show|hide/.test(config)) {
2406          _config.toggle = false;
2407        }
2408
2409        if (!data) {
2410          data = new Collapse(this, _config);
2411          $this.data(DATA_KEY$3, data);
2412        }
2413
2414        if (typeof config === 'string') {
2415          if (typeof data[config] === 'undefined') {
2416            throw new TypeError("No method named \"" + config + "\"");
2417          }
2418
2419          data[config]();
2420        }
2421      });
2422    };
2423
2424    _createClass(Collapse, null, [{
2425      key: "VERSION",
2426      get: function get() {
2427        return VERSION$3;
2428      }
2429    }, {
2430      key: "Default",
2431      get: function get() {
2432        return Default$1;
2433      }
2434    }]);
2435
2436    return Collapse;
2437  }();
2438  /**
2439   * ------------------------------------------------------------------------
2440   * Data Api implementation
2441   * ------------------------------------------------------------------------
2442   */
2443
2444
2445  $(document).on(Event$3.CLICK_DATA_API, Selector$3.DATA_TOGGLE, function (event) {
2446    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
2447    if (event.currentTarget.tagName === 'A') {
2448      event.preventDefault();
2449    }
2450
2451    var $trigger = $(this);
2452    var selector = Util.getSelectorFromElement(this);
2453    var selectors = [].slice.call(document.querySelectorAll(selector));
2454    $(selectors).each(function () {
2455      var $target = $(this);
2456      var data = $target.data(DATA_KEY$3);
2457      var config = data ? 'toggle' : $trigger.data();
2458
2459      Collapse._jQueryInterface.call($target, config);
2460    });
2461  });
2462  /**
2463   * ------------------------------------------------------------------------
2464   * jQuery
2465   * ------------------------------------------------------------------------
2466   */
2467
2468  $.fn[NAME$3] = Collapse._jQueryInterface;
2469  $.fn[NAME$3].Constructor = Collapse;
2470
2471  $.fn[NAME$3].noConflict = function () {
2472    $.fn[NAME$3] = JQUERY_NO_CONFLICT$3;
2473    return Collapse._jQueryInterface;
2474  };
2475
2476  /**
2477   * ------------------------------------------------------------------------
2478   * Constants
2479   * ------------------------------------------------------------------------
2480   */
2481
2482  var NAME$4 = 'dropdown';
2483  var VERSION$4 = '4.3.1';
2484  var DATA_KEY$4 = 'bs.dropdown';
2485  var EVENT_KEY$4 = "." + DATA_KEY$4;
2486  var DATA_API_KEY$4 = '.data-api';
2487  var JQUERY_NO_CONFLICT$4 = $.fn[NAME$4];
2488  var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
2489
2490  var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
2491
2492  var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
2493
2494  var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
2495
2496  var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
2497
2498  var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
2499
2500  var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
2501  var Event$4 = {
2502    HIDE: "hide" + EVENT_KEY$4,
2503    HIDDEN: "hidden" + EVENT_KEY$4,
2504    SHOW: "show" + EVENT_KEY$4,
2505    SHOWN: "shown" + EVENT_KEY$4,
2506    CLICK: "click" + EVENT_KEY$4,
2507    CLICK_DATA_API: "click" + EVENT_KEY$4 + DATA_API_KEY$4,
2508    KEYDOWN_DATA_API: "keydown" + EVENT_KEY$4 + DATA_API_KEY$4,
2509    KEYUP_DATA_API: "keyup" + EVENT_KEY$4 + DATA_API_KEY$4
2510  };
2511  var ClassName$4 = {
2512    DISABLED: 'disabled',
2513    SHOW: 'show',
2514    DROPUP: 'dropup',
2515    DROPRIGHT: 'dropright',
2516    DROPLEFT: 'dropleft',
2517    MENURIGHT: 'dropdown-menu-right',
2518    MENULEFT: 'dropdown-menu-left',
2519    POSITION_STATIC: 'position-static'
2520  };
2521  var Selector$4 = {
2522    DATA_TOGGLE: '[data-toggle="dropdown"]',
2523    FORM_CHILD: '.dropdown form',
2524    MENU: '.dropdown-menu',
2525    NAVBAR_NAV: '.navbar-nav',
2526    VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
2527  };
2528  var AttachmentMap = {
2529    TOP: 'top-start',
2530    TOPEND: 'top-end',
2531    BOTTOM: 'bottom-start',
2532    BOTTOMEND: 'bottom-end',
2533    RIGHT: 'right-start',
2534    RIGHTEND: 'right-end',
2535    LEFT: 'left-start',
2536    LEFTEND: 'left-end'
2537  };
2538  var Default$2 = {
2539    offset: 0,
2540    flip: true,
2541    boundary: 'scrollParent',
2542    reference: 'toggle',
2543    display: 'dynamic'
2544  };
2545  var DefaultType$2 = {
2546    offset: '(number|string|function)',
2547    flip: 'boolean',
2548    boundary: '(string|element)',
2549    reference: '(string|element)',
2550    display: 'string'
2551    /**
2552     * ------------------------------------------------------------------------
2553     * Class Definition
2554     * ------------------------------------------------------------------------
2555     */
2556
2557  };
2558
2559  var Dropdown =
2560  /*#__PURE__*/
2561  function () {
2562    function Dropdown(element, config) {
2563      this._element = element;
2564      this._popper = null;
2565      this._config = this._getConfig(config);
2566      this._menu = this._getMenuElement();
2567      this._inNavbar = this._detectNavbar();
2568
2569      this._addEventListeners();
2570    } // Getters
2571
2572
2573    var _proto = Dropdown.prototype;
2574
2575    // Public
2576    _proto.toggle = function toggle() {
2577      if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED)) {
2578        return;
2579      }
2580
2581      var parent = Dropdown._getParentFromElement(this._element);
2582
2583      var isActive = $(this._menu).hasClass(ClassName$4.SHOW);
2584
2585      Dropdown._clearMenus();
2586
2587      if (isActive) {
2588        return;
2589      }
2590
2591      var relatedTarget = {
2592        relatedTarget: this._element
2593      };
2594      var showEvent = $.Event(Event$4.SHOW, relatedTarget);
2595      $(parent).trigger(showEvent);
2596
2597      if (showEvent.isDefaultPrevented()) {
2598        return;
2599      } // Disable totally Popper.js for Dropdown in Navbar
2600
2601
2602      if (!this._inNavbar) {
2603        /**
2604         * Check for Popper dependency
2605         * Popper - https://popper.js.org
2606         */
2607        if (typeof Popper === 'undefined') {
2608          throw new TypeError('Bootstrap\'s dropdowns require Popper.js (https://popper.js.org/)');
2609        }
2610
2611        var referenceElement = this._element;
2612
2613        if (this._config.reference === 'parent') {
2614          referenceElement = parent;
2615        } else if (Util.isElement(this._config.reference)) {
2616          referenceElement = this._config.reference; // Check if it's jQuery element
2617
2618          if (typeof this._config.reference.jquery !== 'undefined') {
2619            referenceElement = this._config.reference[0];
2620          }
2621        } // If boundary is not `scrollParent`, then set position to `static`
2622        // to allow the menu to "escape" the scroll parent's boundaries
2623        // https://github.com/twbs/bootstrap/issues/24251
2624
2625
2626        if (this._config.boundary !== 'scrollParent') {
2627          $(parent).addClass(ClassName$4.POSITION_STATIC);
2628        }
2629
2630        this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig());
2631      } // If this is a touch-enabled device we add extra
2632      // empty mouseover listeners to the body's immediate children;
2633      // only needed because of broken event delegation on iOS
2634      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
2635
2636
2637      if ('ontouchstart' in document.documentElement && $(parent).closest(Selector$4.NAVBAR_NAV).length === 0) {
2638        $(document.body).children().on('mouseover', null, $.noop);
2639      }
2640
2641      this._element.focus();
2642
2643      this._element.setAttribute('aria-expanded', true);
2644
2645      $(this._menu).toggleClass(ClassName$4.SHOW);
2646      $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget));
2647    };
2648
2649    _proto.show = function show() {
2650      if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || $(this._menu).hasClass(ClassName$4.SHOW)) {
2651        return;
2652      }
2653
2654      var relatedTarget = {
2655        relatedTarget: this._element
2656      };
2657      var showEvent = $.Event(Event$4.SHOW, relatedTarget);
2658
2659      var parent = Dropdown._getParentFromElement(this._element);
2660
2661      $(parent).trigger(showEvent);
2662
2663      if (showEvent.isDefaultPrevented()) {
2664        return;
2665      }
2666
2667      $(this._menu).toggleClass(ClassName$4.SHOW);
2668      $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget));
2669    };
2670
2671    _proto.hide = function hide() {
2672      if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || !$(this._menu).hasClass(ClassName$4.SHOW)) {
2673        return;
2674      }
2675
2676      var relatedTarget = {
2677        relatedTarget: this._element
2678      };
2679      var hideEvent = $.Event(Event$4.HIDE, relatedTarget);
2680
2681      var parent = Dropdown._getParentFromElement(this._element);
2682
2683      $(parent).trigger(hideEvent);
2684
2685      if (hideEvent.isDefaultPrevented()) {
2686        return;
2687      }
2688
2689      $(this._menu).toggleClass(ClassName$4.SHOW);
2690      $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget));
2691    };
2692
2693    _proto.dispose = function dispose() {
2694      $.removeData(this._element, DATA_KEY$4);
2695      $(this._element).off(EVENT_KEY$4);
2696      this._element = null;
2697      this._menu = null;
2698
2699      if (this._popper !== null) {
2700        this._popper.destroy();
2701
2702        this._popper = null;
2703      }
2704    };
2705
2706    _proto.update = function update() {
2707      this._inNavbar = this._detectNavbar();
2708
2709      if (this._popper !== null) {
2710        this._popper.scheduleUpdate();
2711      }
2712    } // Private
2713    ;
2714
2715    _proto._addEventListeners = function _addEventListeners() {
2716      var _this = this;
2717
2718      $(this._element).on(Event$4.CLICK, function (event) {
2719        event.preventDefault();
2720        event.stopPropagation();
2721
2722        _this.toggle();
2723      });
2724    };
2725
2726    _proto._getConfig = function _getConfig(config) {
2727      config = _objectSpread({}, this.constructor.Default, $(this._element).data(), config);
2728      Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType);
2729      return config;
2730    };
2731
2732    _proto._getMenuElement = function _getMenuElement() {
2733      if (!this._menu) {
2734        var parent = Dropdown._getParentFromElement(this._element);
2735
2736        if (parent) {
2737          this._menu = parent.querySelector(Selector$4.MENU);
2738        }
2739      }
2740
2741      return this._menu;
2742    };
2743
2744    _proto._getPlacement = function _getPlacement() {
2745      var $parentDropdown = $(this._element.parentNode);
2746      var placement = AttachmentMap.BOTTOM; // Handle dropup
2747
2748      if ($parentDropdown.hasClass(ClassName$4.DROPUP)) {
2749        placement = AttachmentMap.TOP;
2750
2751        if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) {
2752          placement = AttachmentMap.TOPEND;
2753        }
2754      } else if ($parentDropdown.hasClass(ClassName$4.DROPRIGHT)) {
2755        placement = AttachmentMap.RIGHT;
2756      } else if ($parentDropdown.hasClass(ClassName$4.DROPLEFT)) {
2757        placement = AttachmentMap.LEFT;
2758      } else if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) {
2759        placement = AttachmentMap.BOTTOMEND;
2760      }
2761
2762      return placement;
2763    };
2764
2765    _proto._detectNavbar = function _detectNavbar() {
2766      return $(this._element).closest('.navbar').length > 0;
2767    };
2768
2769    _proto._getOffset = function _getOffset() {
2770      var _this2 = this;
2771
2772      var offset = {};
2773
2774      if (typeof this._config.offset === 'function') {
2775        offset.fn = function (data) {
2776          data.offsets = _objectSpread({}, data.offsets, _this2._config.offset(data.offsets, _this2._element) || {});
2777          return data;
2778        };
2779      } else {
2780        offset.offset = this._config.offset;
2781      }
2782
2783      return offset;
2784    };
2785
2786    _proto._getPopperConfig = function _getPopperConfig() {
2787      var popperConfig = {
2788        placement: this._getPlacement(),
2789        modifiers: {
2790          offset: this._getOffset(),
2791          flip: {
2792            enabled: this._config.flip
2793          },
2794          preventOverflow: {
2795            boundariesElement: this._config.boundary
2796          }
2797        } // Disable Popper.js if we have a static display
2798
2799      };
2800
2801      if (this._config.display === 'static') {
2802        popperConfig.modifiers.applyStyle = {
2803          enabled: false
2804        };
2805      }
2806
2807      return popperConfig;
2808    } // Static
2809    ;
2810
2811    Dropdown._jQueryInterface = function _jQueryInterface(config) {
2812      return this.each(function () {
2813        var data = $(this).data(DATA_KEY$4);
2814
2815        var _config = typeof config === 'object' ? config : null;
2816
2817        if (!data) {
2818          data = new Dropdown(this, _config);
2819          $(this).data(DATA_KEY$4, data);
2820        }
2821
2822        if (typeof config === 'string') {
2823          if (typeof data[config] === 'undefined') {
2824            throw new TypeError("No method named \"" + config + "\"");
2825          }
2826
2827          data[config]();
2828        }
2829      });
2830    };
2831
2832    Dropdown._clearMenus = function _clearMenus(event) {
2833      if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
2834        return;
2835      }
2836
2837      var toggles = [].slice.call(document.querySelectorAll(Selector$4.DATA_TOGGLE));
2838
2839      for (var i = 0, len = toggles.length; i < len; i++) {
2840        var parent = Dropdown._getParentFromElement(toggles[i]);
2841
2842        var context = $(toggles[i]).data(DATA_KEY$4);
2843        var relatedTarget = {
2844          relatedTarget: toggles[i]
2845        };
2846
2847        if (event && event.type === 'click') {
2848          relatedTarget.clickEvent = event;
2849        }
2850
2851        if (!context) {
2852          continue;
2853        }
2854
2855        var dropdownMenu = context._menu;
2856
2857        if (!$(parent).hasClass(ClassName$4.SHOW)) {
2858          continue;
2859        }
2860
2861        if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $.contains(parent, event.target)) {
2862          continue;
2863        }
2864
2865        var hideEvent = $.Event(Event$4.HIDE, relatedTarget);
2866        $(parent).trigger(hideEvent);
2867
2868        if (hideEvent.isDefaultPrevented()) {
2869          continue;
2870        } // If this is a touch-enabled device we remove the extra
2871        // empty mouseover listeners we added for iOS support
2872
2873
2874        if ('ontouchstart' in document.documentElement) {
2875          $(document.body).children().off('mouseover', null, $.noop);
2876        }
2877
2878        toggles[i].setAttribute('aria-expanded', 'false');
2879        $(dropdownMenu).removeClass(ClassName$4.SHOW);
2880        $(parent).removeClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget));
2881      }
2882    };
2883
2884    Dropdown._getParentFromElement = function _getParentFromElement(element) {
2885      var parent;
2886      var selector = Util.getSelectorFromElement(element);
2887
2888      if (selector) {
2889        parent = document.querySelector(selector);
2890      }
2891
2892      return parent || element.parentNode;
2893    } // eslint-disable-next-line complexity
2894    ;
2895
2896    Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
2897      // If not input/textarea:
2898      //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
2899      // If input/textarea:
2900      //  - If space key => not a dropdown command
2901      //  - If key is other than escape
2902      //    - If key is not up or down => not a dropdown command
2903      //    - If trigger inside the menu => not a dropdown command
2904      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 || $(event.target).closest(Selector$4.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
2905        return;
2906      }
2907
2908      event.preventDefault();
2909      event.stopPropagation();
2910
2911      if (this.disabled || $(this).hasClass(ClassName$4.DISABLED)) {
2912        return;
2913      }
2914
2915      var parent = Dropdown._getParentFromElement(this);
2916
2917      var isActive = $(parent).hasClass(ClassName$4.SHOW);
2918
2919      if (!isActive || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
2920        if (event.which === ESCAPE_KEYCODE) {
2921          var toggle = parent.querySelector(Selector$4.DATA_TOGGLE);
2922          $(toggle).trigger('focus');
2923        }
2924
2925        $(this).trigger('click');
2926        return;
2927      }
2928
2929      var items = [].slice.call(parent.querySelectorAll(Selector$4.VISIBLE_ITEMS));
2930
2931      if (items.length === 0) {
2932        return;
2933      }
2934
2935      var index = items.indexOf(event.target);
2936
2937      if (event.which === ARROW_UP_KEYCODE && index > 0) {
2938        // Up
2939        index--;
2940      }
2941
2942      if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
2943        // Down
2944        index++;
2945      }
2946
2947      if (index < 0) {
2948        index = 0;
2949      }
2950
2951      items[index].focus();
2952    };
2953
2954    _createClass(Dropdown, null, [{
2955      key: "VERSION",
2956      get: function get() {
2957        return VERSION$4;
2958      }
2959    }, {
2960      key: "Default",
2961      get: function get() {
2962        return Default$2;
2963      }
2964    }, {
2965      key: "DefaultType",
2966      get: function get() {
2967        return DefaultType$2;
2968      }
2969    }]);
2970
2971    return Dropdown;
2972  }();
2973  /**
2974   * ------------------------------------------------------------------------
2975   * Data Api implementation
2976   * ------------------------------------------------------------------------
2977   */
2978
2979
2980  $(document).on(Event$4.KEYDOWN_DATA_API, Selector$4.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event$4.KEYDOWN_DATA_API, Selector$4.MENU, Dropdown._dataApiKeydownHandler).on(Event$4.CLICK_DATA_API + " " + Event$4.KEYUP_DATA_API, Dropdown._clearMenus).on(Event$4.CLICK_DATA_API, Selector$4.DATA_TOGGLE, function (event) {
2981    event.preventDefault();
2982    event.stopPropagation();
2983
2984    Dropdown._jQueryInterface.call($(this), 'toggle');
2985  }).on(Event$4.CLICK_DATA_API, Selector$4.FORM_CHILD, function (e) {
2986    e.stopPropagation();
2987  });
2988  /**
2989   * ------------------------------------------------------------------------
2990   * jQuery
2991   * ------------------------------------------------------------------------
2992   */
2993
2994  $.fn[NAME$4] = Dropdown._jQueryInterface;
2995  $.fn[NAME$4].Constructor = Dropdown;
2996
2997  $.fn[NAME$4].noConflict = function () {
2998    $.fn[NAME$4] = JQUERY_NO_CONFLICT$4;
2999    return Dropdown._jQueryInterface;
3000  };
3001
3002  /**
3003   * ------------------------------------------------------------------------
3004   * Constants
3005   * ------------------------------------------------------------------------
3006   */
3007
3008  var NAME$5 = 'modal';
3009  var VERSION$5 = '4.3.1';
3010  var DATA_KEY$5 = 'bs.modal';
3011  var EVENT_KEY$5 = "." + DATA_KEY$5;
3012  var DATA_API_KEY$5 = '.data-api';
3013  var JQUERY_NO_CONFLICT$5 = $.fn[NAME$5];
3014  var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key
3015
3016  var Default$3 = {
3017    backdrop: true,
3018    keyboard: true,
3019    focus: true,
3020    show: true
3021  };
3022  var DefaultType$3 = {
3023    backdrop: '(boolean|string)',
3024    keyboard: 'boolean',
3025    focus: 'boolean',
3026    show: 'boolean'
3027  };
3028  var Event$5 = {
3029    HIDE: "hide" + EVENT_KEY$5,
3030    HIDDEN: "hidden" + EVENT_KEY$5,
3031    SHOW: "show" + EVENT_KEY$5,
3032    SHOWN: "shown" + EVENT_KEY$5,
3033    FOCUSIN: "focusin" + EVENT_KEY$5,
3034    RESIZE: "resize" + EVENT_KEY$5,
3035    CLICK_DISMISS: "click.dismiss" + EVENT_KEY$5,
3036    KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY$5,
3037    MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY$5,
3038    MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY$5,
3039    CLICK_DATA_API: "click" + EVENT_KEY$5 + DATA_API_KEY$5
3040  };
3041  var ClassName$5 = {
3042    SCROLLABLE: 'modal-dialog-scrollable',
3043    SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
3044    BACKDROP: 'modal-backdrop',
3045    OPEN: 'modal-open',
3046    FADE: 'fade',
3047    SHOW: 'show'
3048  };
3049  var Selector$5 = {
3050    DIALOG: '.modal-dialog',
3051    MODAL_BODY: '.modal-body',
3052    DATA_TOGGLE: '[data-toggle="modal"]',
3053    DATA_DISMISS: '[data-dismiss="modal"]',
3054    FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
3055    STICKY_CONTENT: '.sticky-top'
3056    /**
3057     * ------------------------------------------------------------------------
3058     * Class Definition
3059     * ------------------------------------------------------------------------
3060     */
3061
3062  };
3063
3064  var Modal =
3065  /*#__PURE__*/
3066  function () {
3067    function Modal(element, config) {
3068      this._config = this._getConfig(config);
3069      this._element = element;
3070      this._dialog = element.querySelector(Selector$5.DIALOG);
3071      this._backdrop = null;
3072      this._isShown = false;
3073      this._isBodyOverflowing = false;
3074      this._ignoreBackdropClick = false;
3075      this._isTransitioning = false;
3076      this._scrollbarWidth = 0;
3077    } // Getters
3078
3079
3080    var _proto = Modal.prototype;
3081
3082    // Public
3083    _proto.toggle = function toggle(relatedTarget) {
3084      return this._isShown ? this.hide() : this.show(relatedTarget);
3085    };
3086
3087    _proto.show = function show(relatedTarget) {
3088      var _this = this;
3089
3090      if (this._isShown || this._isTransitioning) {
3091        return;
3092      }
3093
3094      if ($(this._element).hasClass(ClassName$5.FADE)) {
3095        this._isTransitioning = true;
3096      }
3097
3098      var showEvent = $.Event(Event$5.SHOW, {
3099        relatedTarget: relatedTarget
3100      });
3101      $(this._element).trigger(showEvent);
3102
3103      if (this._isShown || showEvent.isDefaultPrevented()) {
3104        return;
3105      }
3106
3107      this._isShown = true;
3108
3109      this._checkScrollbar();
3110
3111      this._setScrollbar();
3112
3113      this._adjustDialog();
3114
3115      this._setEscapeEvent();
3116
3117      this._setResizeEvent();
3118
3119      $(this._element).on(Event$5.CLICK_DISMISS, Selector$5.DATA_DISMISS, function (event) {
3120        return _this.hide(event);
3121      });
3122      $(this._dialog).on(Event$5.MOUSEDOWN_DISMISS, function () {
3123        $(_this._element).one(Event$5.MOUSEUP_DISMISS, function (event) {
3124          if ($(event.target).is(_this._element)) {
3125            _this._ignoreBackdropClick = true;
3126          }
3127        });
3128      });
3129
3130      this._showBackdrop(function () {
3131        return _this._showElement(relatedTarget);
3132      });
3133    };
3134
3135    _proto.hide = function hide(event) {
3136      var _this2 = this;
3137
3138      if (event) {
3139        event.preventDefault();
3140      }
3141
3142      if (!this._isShown || this._isTransitioning) {
3143        return;
3144      }
3145
3146      var hideEvent = $.Event(Event$5.HIDE);
3147      $(this._element).trigger(hideEvent);
3148
3149      if (!this._isShown || hideEvent.isDefaultPrevented()) {
3150        return;
3151      }
3152
3153      this._isShown = false;
3154      var transition = $(this._element).hasClass(ClassName$5.FADE);
3155
3156      if (transition) {
3157        this._isTransitioning = true;
3158      }
3159
3160      this._setEscapeEvent();
3161
3162      this._setResizeEvent();
3163
3164      $(document).off(Event$5.FOCUSIN);
3165      $(this._element).removeClass(ClassName$5.SHOW);
3166      $(this._element).off(Event$5.CLICK_DISMISS);
3167      $(this._dialog).off(Event$5.MOUSEDOWN_DISMISS);
3168
3169      if (transition) {
3170        var transitionDuration = Util.getTransitionDurationFromElement(this._element);
3171        $(this._element).one(Util.TRANSITION_END, function (event) {
3172          return _this2._hideModal(event);
3173        }).emulateTransitionEnd(transitionDuration);
3174      } else {
3175        this._hideModal();
3176      }
3177    };
3178
3179    _proto.dispose = function dispose() {
3180      [window, this._element, this._dialog].forEach(function (htmlElement) {
3181        return $(htmlElement).off(EVENT_KEY$5);
3182      });
3183      /**
3184       * `document` has 2 events `Event.FOCUSIN` and `Event.CLICK_DATA_API`
3185       * Do not move `document` in `htmlElements` array
3186       * It will remove `Event.CLICK_DATA_API` event that should remain
3187       */
3188
3189      $(document).off(Event$5.FOCUSIN);
3190      $.removeData(this._element, DATA_KEY$5);
3191      this._config = null;
3192      this._element = null;
3193      this._dialog = null;
3194      this._backdrop = null;
3195      this._isShown = null;
3196      this._isBodyOverflowing = null;
3197      this._ignoreBackdropClick = null;
3198      this._isTransitioning = null;
3199      this._scrollbarWidth = null;
3200    };
3201
3202    _proto.handleUpdate = function handleUpdate() {
3203      this._adjustDialog();
3204    } // Private
3205    ;
3206
3207    _proto._getConfig = function _getConfig(config) {
3208      config = _objectSpread({}, Default$3, config);
3209      Util.typeCheckConfig(NAME$5, config, DefaultType$3);
3210      return config;
3211    };
3212
3213    _proto._showElement = function _showElement(relatedTarget) {
3214      var _this3 = this;
3215
3216      var transition = $(this._element).hasClass(ClassName$5.FADE);
3217
3218      if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
3219        // Don't move modal's DOM position
3220        document.body.appendChild(this._element);
3221      }
3222
3223      this._element.style.display = 'block';
3224
3225      this._element.removeAttribute('aria-hidden');
3226
3227      this._element.setAttribute('aria-modal', true);
3228
3229      if ($(this._dialog).hasClass(ClassName$5.SCROLLABLE)) {
3230        this._dialog.querySelector(Selector$5.MODAL_BODY).scrollTop = 0;
3231      } else {
3232        this._element.scrollTop = 0;
3233      }
3234
3235      if (transition) {
3236        Util.reflow(this._element);
3237      }
3238
3239      $(this._element).addClass(ClassName$5.SHOW);
3240
3241      if (this._config.focus) {
3242        this._enforceFocus();
3243      }
3244
3245      var shownEvent = $.Event(Event$5.SHOWN, {
3246        relatedTarget: relatedTarget
3247      });
3248
3249      var transitionComplete = function transitionComplete() {
3250        if (_this3._config.focus) {
3251          _this3._element.focus();
3252        }
3253
3254        _this3._isTransitioning = false;
3255        $(_this3._element).trigger(shownEvent);
3256      };
3257
3258      if (transition) {
3259        var transitionDuration = Util.getTransitionDurationFromElement(this._dialog);
3260        $(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration);
3261      } else {
3262        transitionComplete();
3263      }
3264    };
3265
3266    _proto._enforceFocus = function _enforceFocus() {
3267      var _this4 = this;
3268
3269      $(document).off(Event$5.FOCUSIN) // Guard against infinite focus loop
3270      .on(Event$5.FOCUSIN, function (event) {
3271        if (document !== event.target && _this4._element !== event.target && $(_this4._element).has(event.target).length === 0) {
3272          _this4._element.focus();
3273        }
3274      });
3275    };
3276
3277    _proto._setEscapeEvent = function _setEscapeEvent() {
3278      var _this5 = this;
3279
3280      if (this._isShown && this._config.keyboard) {
3281        $(this._element).on(Event$5.KEYDOWN_DISMISS, function (event) {
3282          if (event.which === ESCAPE_KEYCODE$1) {
3283            event.preventDefault();
3284
3285            _this5.hide();
3286          }
3287        });
3288      } else if (!this._isShown) {
3289        $(this._element).off(Event$5.KEYDOWN_DISMISS);
3290      }
3291    };
3292
3293    _proto._setResizeEvent = function _setResizeEvent() {
3294      var _this6 = this;
3295
3296      if (this._isShown) {
3297        $(window).on(Event$5.RESIZE, function (event) {
3298          return _this6.handleUpdate(event);
3299        });
3300      } else {
3301        $(window).off(Event$5.RESIZE);
3302      }
3303    };
3304
3305    _proto._hideModal = function _hideModal() {
3306      var _this7 = this;
3307
3308      this._element.style.display = 'none';
3309
3310      this._element.setAttribute('aria-hidden', true);
3311
3312      this._element.removeAttribute('aria-modal');
3313
3314      this._isTransitioning = false;
3315
3316      this._showBackdrop(function () {
3317        $(document.body).removeClass(ClassName$5.OPEN);
3318
3319        _this7._resetAdjustments();
3320
3321        _this7._resetScrollbar();
3322
3323        $(_this7._element).trigger(Event$5.HIDDEN);
3324      });
3325    };
3326
3327    _proto._removeBackdrop = function _removeBackdrop() {
3328      if (this._backdrop) {
3329        $(this._backdrop).remove();
3330        this._backdrop = null;
3331      }
3332    };
3333
3334    _proto._showBackdrop = function _showBackdrop(callback) {
3335      var _this8 = this;
3336
3337      var animate = $(this._element).hasClass(ClassName$5.FADE) ? ClassName$5.FADE : '';
3338
3339      if (this._isShown && this._config.backdrop) {
3340        this._backdrop = document.createElement('div');
3341        this._backdrop.className = ClassName$5.BACKDROP;
3342
3343        if (animate) {
3344          this._backdrop.classList.add(animate);
3345        }
3346
3347        $(this._backdrop).appendTo(document.body);
3348        $(this._element).on(Event$5.CLICK_DISMISS, function (event) {
3349          if (_this8._ignoreBackdropClick) {
3350            _this8._ignoreBackdropClick = false;
3351            return;
3352          }
3353
3354          if (event.target !== event.currentTarget) {
3355            return;
3356          }
3357
3358          if (_this8._config.backdrop === 'static') {
3359            _this8._element.focus();
3360          } else {
3361            _this8.hide();
3362          }
3363        });
3364
3365        if (animate) {
3366          Util.reflow(this._backdrop);
3367        }
3368
3369        $(this._backdrop).addClass(ClassName$5.SHOW);
3370
3371        if (!callback) {
3372          return;
3373        }
3374
3375        if (!animate) {
3376          callback();
3377          return;
3378        }
3379
3380        var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
3381        $(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration);
3382      } else if (!this._isShown && this._backdrop) {
3383        $(this._backdrop).removeClass(ClassName$5.SHOW);
3384
3385        var callbackRemove = function callbackRemove() {
3386          _this8._removeBackdrop();
3387
3388          if (callback) {
3389            callback();
3390          }
3391        };
3392
3393        if ($(this._element).hasClass(ClassName$5.FADE)) {
3394          var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
3395
3396          $(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration);
3397        } else {
3398          callbackRemove();
3399        }
3400      } else if (callback) {
3401        callback();
3402      }
3403    } // ----------------------------------------------------------------------
3404    // the following methods are used to handle overflowing modals
3405    // todo (fat): these should probably be refactored out of modal.js
3406    // ----------------------------------------------------------------------
3407    ;
3408
3409    _proto._adjustDialog = function _adjustDialog() {
3410      var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
3411
3412      if (!this._isBodyOverflowing && isModalOverflowing) {
3413        this._element.style.paddingLeft = this._scrollbarWidth + "px";
3414      }
3415
3416      if (this._isBodyOverflowing && !isModalOverflowing) {
3417        this._element.style.paddingRight = this._scrollbarWidth + "px";
3418      }
3419    };
3420
3421    _proto._resetAdjustments = function _resetAdjustments() {
3422      this._element.style.paddingLeft = '';
3423      this._element.style.paddingRight = '';
3424    };
3425
3426    _proto._checkScrollbar = function _checkScrollbar() {
3427      var rect = document.body.getBoundingClientRect();
3428      this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
3429      this._scrollbarWidth = this._getScrollbarWidth();
3430    };
3431
3432    _proto._setScrollbar = function _setScrollbar() {
3433      var _this9 = this;
3434
3435      if (this._isBodyOverflowing) {
3436        // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
3437        //   while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
3438        var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT));
3439        var stickyContent = [].slice.call(document.querySelectorAll(Selector$5.STICKY_CONTENT)); // Adjust fixed content padding
3440
3441        $(fixedContent).each(function (index, element) {
3442          var actualPadding = element.style.paddingRight;
3443          var calculatedPadding = $(element).css('padding-right');
3444          $(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
3445        }); // Adjust sticky content margin
3446
3447        $(stickyContent).each(function (index, element) {
3448          var actualMargin = element.style.marginRight;
3449          var calculatedMargin = $(element).css('margin-right');
3450          $(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
3451        }); // Adjust body padding
3452
3453        var actualPadding = document.body.style.paddingRight;
3454        var calculatedPadding = $(document.body).css('padding-right');
3455        $(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
3456      }
3457
3458      $(document.body).addClass(ClassName$5.OPEN);
3459    };
3460
3461    _proto._resetScrollbar = function _resetScrollbar() {
3462      // Restore fixed content padding
3463      var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT));
3464      $(fixedContent).each(function (index, element) {
3465        var padding = $(element).data('padding-right');
3466        $(element).removeData('padding-right');
3467        element.style.paddingRight = padding ? padding : '';
3468      }); // Restore sticky content
3469
3470      var elements = [].slice.call(document.querySelectorAll("" + Selector$5.STICKY_CONTENT));
3471      $(elements).each(function (index, element) {
3472        var margin = $(element).data('margin-right');
3473
3474        if (typeof margin !== 'undefined') {
3475          $(element).css('margin-right', margin).removeData('margin-right');
3476        }
3477      }); // Restore body padding
3478
3479      var padding = $(document.body).data('padding-right');
3480      $(document.body).removeData('padding-right');
3481      document.body.style.paddingRight = padding ? padding : '';
3482    };
3483
3484    _proto._getScrollbarWidth = function _getScrollbarWidth() {
3485      // thx d.walsh
3486      var scrollDiv = document.createElement('div');
3487      scrollDiv.className = ClassName$5.SCROLLBAR_MEASURER;
3488      document.body.appendChild(scrollDiv);
3489      var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
3490      document.body.removeChild(scrollDiv);
3491      return scrollbarWidth;
3492    } // Static
3493    ;
3494
3495    Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
3496      return this.each(function () {
3497        var data = $(this).data(DATA_KEY$5);
3498
3499        var _config = _objectSpread({}, Default$3, $(this).data(), typeof config === 'object' && config ? config : {});
3500
3501        if (!data) {
3502          data = new Modal(this, _config);
3503          $(this).data(DATA_KEY$5, data);
3504        }
3505
3506        if (typeof config === 'string') {
3507          if (typeof data[config] === 'undefined') {
3508            throw new TypeError("No method named \"" + config + "\"");
3509          }
3510
3511          data[config](relatedTarget);
3512        } else if (_config.show) {
3513          data.show(relatedTarget);
3514        }
3515      });
3516    };
3517
3518    _createClass(Modal, null, [{
3519      key: "VERSION",
3520      get: function get() {
3521        return VERSION$5;
3522      }
3523    }, {
3524      key: "Default",
3525      get: function get() {
3526        return Default$3;
3527      }
3528    }]);
3529
3530    return Modal;
3531  }();
3532  /**
3533   * ------------------------------------------------------------------------
3534   * Data Api implementation
3535   * ------------------------------------------------------------------------
3536   */
3537
3538
3539  $(document).on(Event$5.CLICK_DATA_API, Selector$5.DATA_TOGGLE, function (event) {
3540    var _this10 = this;
3541
3542    var target;
3543    var selector = Util.getSelectorFromElement(this);
3544
3545    if (selector) {
3546      target = document.querySelector(selector);
3547    }
3548
3549    var config = $(target).data(DATA_KEY$5) ? 'toggle' : _objectSpread({}, $(target).data(), $(this).data());
3550
3551    if (this.tagName === 'A' || this.tagName === 'AREA') {
3552      event.preventDefault();
3553    }
3554
3555    var $target = $(target).one(Event$5.SHOW, function (showEvent) {
3556      if (showEvent.isDefaultPrevented()) {
3557        // Only register focus restorer if modal will actually get shown
3558        return;
3559      }
3560
3561      $target.one(Event$5.HIDDEN, function () {
3562        if ($(_this10).is(':visible')) {
3563          _this10.focus();
3564        }
3565      });
3566    });
3567
3568    Modal._jQueryInterface.call($(target), config, this);
3569  });
3570  /**
3571   * ------------------------------------------------------------------------
3572   * jQuery
3573   * ------------------------------------------------------------------------
3574   */
3575
3576  $.fn[NAME$5] = Modal._jQueryInterface;
3577  $.fn[NAME$5].Constructor = Modal;
3578
3579  $.fn[NAME$5].noConflict = function () {
3580    $.fn[NAME$5] = JQUERY_NO_CONFLICT$5;
3581    return Modal._jQueryInterface;
3582  };
3583
3584  /**
3585   * --------------------------------------------------------------------------
3586   * Bootstrap (v4.3.1): tools/sanitizer.js
3587   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3588   * --------------------------------------------------------------------------
3589   */
3590  var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href'];
3591  var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
3592  var DefaultWhitelist = {
3593    // Global attributes allowed on any supplied element below.
3594    '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
3595    a: ['target', 'href', 'title', 'rel'],
3596    area: [],
3597    b: [],
3598    br: [],
3599    col: [],
3600    code: [],
3601    div: [],
3602    em: [],
3603    hr: [],
3604    h1: [],
3605    h2: [],
3606    h3: [],
3607    h4: [],
3608    h5: [],
3609    h6: [],
3610    i: [],
3611    img: ['src', 'alt', 'title', 'width', 'height'],
3612    li: [],
3613    ol: [],
3614    p: [],
3615    pre: [],
3616    s: [],
3617    small: [],
3618    span: [],
3619    sub: [],
3620    sup: [],
3621    strong: [],
3622    u: [],
3623    ul: []
3624    /**
3625     * A pattern that recognizes a commonly useful subset of URLs that are safe.
3626     *
3627     * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
3628     */
3629
3630  };
3631  var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;
3632  /**
3633   * A pattern that matches safe data URLs. Only matches image, video and audio types.
3634   *
3635   * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
3636   */
3637
3638  var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;
3639
3640  function allowedAttribute(attr, allowedAttributeList) {
3641    var attrName = attr.nodeName.toLowerCase();
3642
3643    if (allowedAttributeList.indexOf(attrName) !== -1) {
3644      if (uriAttrs.indexOf(attrName) !== -1) {
3645        return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN));
3646      }
3647
3648      return true;
3649    }
3650
3651    var regExp = allowedAttributeList.filter(function (attrRegex) {
3652      return attrRegex instanceof RegExp;
3653    }); // Check if a regular expression validates the attribute.
3654
3655    for (var i = 0, l = regExp.length; i < l; i++) {
3656      if (attrName.match(regExp[i])) {
3657        return true;
3658      }
3659    }
3660
3661    return false;
3662  }
3663
3664  function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) {
3665    if (unsafeHtml.length === 0) {
3666      return unsafeHtml;
3667    }
3668
3669    if (sanitizeFn && typeof sanitizeFn === 'function') {
3670      return sanitizeFn(unsafeHtml);
3671    }
3672
3673    var domParser = new window.DOMParser();
3674    var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
3675    var whitelistKeys = Object.keys(whiteList);
3676    var elements = [].slice.call(createdDocument.body.querySelectorAll('*'));
3677
3678    var _loop = function _loop(i, len) {
3679      var el = elements[i];
3680      var elName = el.nodeName.toLowerCase();
3681
3682      if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) {
3683        el.parentNode.removeChild(el);
3684        return "continue";
3685      }
3686
3687      var attributeList = [].slice.call(el.attributes);
3688      var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []);
3689      attributeList.forEach(function (attr) {
3690        if (!allowedAttribute(attr, whitelistedAttributes)) {
3691          el.removeAttribute(attr.nodeName);
3692        }
3693      });
3694    };
3695
3696    for (var i = 0, len = elements.length; i < len; i++) {
3697      var _ret = _loop(i, len);
3698
3699      if (_ret === "continue") continue;
3700    }
3701
3702    return createdDocument.body.innerHTML;
3703  }
3704
3705  /**
3706   * ------------------------------------------------------------------------
3707   * Constants
3708   * ------------------------------------------------------------------------
3709   */
3710
3711  var NAME$6 = 'tooltip';
3712  var VERSION$6 = '4.3.1';
3713  var DATA_KEY$6 = 'bs.tooltip';
3714  var EVENT_KEY$6 = "." + DATA_KEY$6;
3715  var JQUERY_NO_CONFLICT$6 = $.fn[NAME$6];
3716  var CLASS_PREFIX = 'bs-tooltip';
3717  var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
3718  var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn'];
3719  var DefaultType$4 = {
3720    animation: 'boolean',
3721    template: 'string',
3722    title: '(string|element|function)',
3723    trigger: 'string',
3724    delay: '(number|object)',
3725    html: 'boolean',
3726    selector: '(string|boolean)',
3727    placement: '(string|function)',
3728    offset: '(number|string|function)',
3729    container: '(string|element|boolean)',
3730    fallbackPlacement: '(string|array)',
3731    boundary: '(string|element)',
3732    sanitize: 'boolean',
3733    sanitizeFn: '(null|function)',
3734    whiteList: 'object'
3735  };
3736  var AttachmentMap$1 = {
3737    AUTO: 'auto',
3738    TOP: 'top',
3739    RIGHT: 'right',
3740    BOTTOM: 'bottom',
3741    LEFT: 'left'
3742  };
3743  var Default$4 = {
3744    animation: true,
3745    template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
3746    trigger: 'hover focus',
3747    title: '',
3748    delay: 0,
3749    html: false,
3750    selector: false,
3751    placement: 'top',
3752    offset: 0,
3753    container: false,
3754    fallbackPlacement: 'flip',
3755    boundary: 'scrollParent',
3756    sanitize: true,
3757    sanitizeFn: null,
3758    whiteList: DefaultWhitelist
3759  };
3760  var HoverState = {
3761    SHOW: 'show',
3762    OUT: 'out'
3763  };
3764  var Event$6 = {
3765    HIDE: "hide" + EVENT_KEY$6,
3766    HIDDEN: "hidden" + EVENT_KEY$6,
3767    SHOW: "show" + EVENT_KEY$6,
3768    SHOWN: "shown" + EVENT_KEY$6,
3769    INSERTED: "inserted" + EVENT_KEY$6,
3770    CLICK: "click" + EVENT_KEY$6,
3771    FOCUSIN: "focusin" + EVENT_KEY$6,
3772    FOCUSOUT: "focusout" + EVENT_KEY$6,
3773    MOUSEENTER: "mouseenter" + EVENT_KEY$6,
3774    MOUSELEAVE: "mouseleave" + EVENT_KEY$6
3775  };
3776  var ClassName$6 = {
3777    FADE: 'fade',
3778    SHOW: 'show'
3779  };
3780  var Selector$6 = {
3781    TOOLTIP: '.tooltip',
3782    TOOLTIP_INNER: '.tooltip-inner',
3783    ARROW: '.arrow'
3784  };
3785  var Trigger = {
3786    HOVER: 'hover',
3787    FOCUS: 'focus',
3788    CLICK: 'click',
3789    MANUAL: 'manual'
3790    /**
3791     * ------------------------------------------------------------------------
3792     * Class Definition
3793     * ------------------------------------------------------------------------
3794     */
3795
3796  };
3797
3798  var Tooltip =
3799  /*#__PURE__*/
3800  function () {
3801    function Tooltip(element, config) {
3802      /**
3803       * Check for Popper dependency
3804       * Popper - https://popper.js.org
3805       */
3806      if (typeof Popper === 'undefined') {
3807        throw new TypeError('Bootstrap\'s tooltips require Popper.js (https://popper.js.org/)');
3808      } // private
3809
3810
3811      this._isEnabled = true;
3812      this._timeout = 0;
3813      this._hoverState = '';
3814      this._activeTrigger = {};
3815      this._popper = null; // Protected
3816
3817      this.element = element;
3818      this.config = this._getConfig(config);
3819      this.tip = null;
3820
3821      this._setListeners();
3822    } // Getters
3823
3824
3825    var _proto = Tooltip.prototype;
3826
3827    // Public
3828    _proto.enable = function enable() {
3829      this._isEnabled = true;
3830    };
3831
3832    _proto.disable = function disable() {
3833      this._isEnabled = false;
3834    };
3835
3836    _proto.toggleEnabled = function toggleEnabled() {
3837      this._isEnabled = !this._isEnabled;
3838    };
3839
3840    _proto.toggle = function toggle(event) {
3841      if (!this._isEnabled) {
3842        return;
3843      }
3844
3845      if (event) {
3846        var dataKey = this.constructor.DATA_KEY;
3847        var context = $(event.currentTarget).data(dataKey);
3848
3849        if (!context) {
3850          context = new this.constructor(event.currentTarget, this._getDelegateConfig());
3851          $(event.currentTarget).data(dataKey, context);
3852        }
3853
3854        context._activeTrigger.click = !context._activeTrigger.click;
3855
3856        if (context._isWithActiveTrigger()) {
3857          context._enter(null, context);
3858        } else {
3859          context._leave(null, context);
3860        }
3861      } else {
3862        if ($(this.getTipElement()).hasClass(ClassName$6.SHOW)) {
3863          this._leave(null, this);
3864
3865          return;
3866        }
3867
3868        this._enter(null, this);
3869      }
3870    };
3871
3872    _proto.dispose = function dispose() {
3873      clearTimeout(this._timeout);
3874      $.removeData(this.element, this.constructor.DATA_KEY);
3875      $(this.element).off(this.constructor.EVENT_KEY);
3876      $(this.element).closest('.modal').off('hide.bs.modal');
3877
3878      if (this.tip) {
3879        $(this.tip).remove();
3880      }
3881
3882      this._isEnabled = null;
3883      this._timeout = null;
3884      this._hoverState = null;
3885      this._activeTrigger = null;
3886
3887      if (this._popper !== null) {
3888        this._popper.destroy();
3889      }
3890
3891      this._popper = null;
3892      this.element = null;
3893      this.config = null;
3894      this.tip = null;
3895    };
3896
3897    _proto.show = function show() {
3898      var _this = this;
3899
3900      if ($(this.element).css('display') === 'none') {
3901        throw new Error('Please use show on visible elements');
3902      }
3903
3904      var showEvent = $.Event(this.constructor.Event.SHOW);
3905
3906      if (this.isWithContent() && this._isEnabled) {
3907        $(this.element).trigger(showEvent);
3908        var shadowRoot = Util.findShadowRoot(this.element);
3909        var isInTheDom = $.contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element);
3910
3911        if (showEvent.isDefaultPrevented() || !isInTheDom) {
3912          return;
3913        }
3914
3915        var tip = this.getTipElement();
3916        var tipId = Util.getUID(this.constructor.NAME);
3917        tip.setAttribute('id', tipId);
3918        this.element.setAttribute('aria-describedby', tipId);
3919        this.setContent();
3920
3921        if (this.config.animation) {
3922          $(tip).addClass(ClassName$6.FADE);
3923        }
3924
3925        var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
3926
3927        var attachment = this._getAttachment(placement);
3928
3929        this.addAttachmentClass(attachment);
3930
3931        var container = this._getContainer();
3932
3933        $(tip).data(this.constructor.DATA_KEY, this);
3934
3935        if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) {
3936          $(tip).appendTo(container);
3937        }
3938
3939        $(this.element).trigger(this.constructor.Event.INSERTED);
3940        this._popper = new Popper(this.element, tip, {
3941          placement: attachment,
3942          modifiers: {
3943            offset: this._getOffset(),
3944            flip: {
3945              behavior: this.config.fallbackPlacement
3946            },
3947            arrow: {
3948              element: Selector$6.ARROW
3949            },
3950            preventOverflow: {
3951              boundariesElement: this.config.boundary
3952            }
3953          },
3954          onCreate: function onCreate(data) {
3955            if (data.originalPlacement !== data.placement) {
3956              _this._handlePopperPlacementChange(data);
3957            }
3958          },
3959          onUpdate: function onUpdate(data) {
3960            return _this._handlePopperPlacementChange(data);
3961          }
3962        });
3963        $(tip).addClass(ClassName$6.SHOW); // If this is a touch-enabled device we add extra
3964        // empty mouseover listeners to the body's immediate children;
3965        // only needed because of broken event delegation on iOS
3966        // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
3967
3968        if ('ontouchstart' in document.documentElement) {
3969          $(document.body).children().on('mouseover', null, $.noop);
3970        }
3971
3972        var complete = function complete() {
3973          if (_this.config.animation) {
3974            _this._fixTransition();
3975          }
3976
3977          var prevHoverState = _this._hoverState;
3978          _this._hoverState = null;
3979          $(_this.element).trigger(_this.constructor.Event.SHOWN);
3980
3981          if (prevHoverState === HoverState.OUT) {
3982            _this._leave(null, _this);
3983          }
3984        };
3985
3986        if ($(this.tip).hasClass(ClassName$6.FADE)) {
3987          var transitionDuration = Util.getTransitionDurationFromElement(this.tip);
3988          $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
3989        } else {
3990          complete();
3991        }
3992      }
3993    };
3994
3995    _proto.hide = function hide(callback) {
3996      var _this2 = this;
3997
3998      var tip = this.getTipElement();
3999      var hideEvent = $.Event(this.constructor.Event.HIDE);
4000
4001      var complete = function complete() {
4002        if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
4003          tip.parentNode.removeChild(tip);
4004        }
4005
4006        _this2._cleanTipClass();
4007
4008        _this2.element.removeAttribute('aria-describedby');
4009
4010        $(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
4011
4012        if (_this2._popper !== null) {
4013          _this2._popper.destroy();
4014        }
4015
4016        if (callback) {
4017          callback();
4018        }
4019      };
4020
4021      $(this.element).trigger(hideEvent);
4022
4023      if (hideEvent.isDefaultPrevented()) {
4024        return;
4025      }
4026
4027      $(tip).removeClass(ClassName$6.SHOW); // If this is a touch-enabled device we remove the extra
4028      // empty mouseover listeners we added for iOS support
4029
4030      if ('ontouchstart' in document.documentElement) {
4031        $(document.body).children().off('mouseover', null, $.noop);
4032      }
4033
4034      this._activeTrigger[Trigger.CLICK] = false;
4035      this._activeTrigger[Trigger.FOCUS] = false;
4036      this._activeTrigger[Trigger.HOVER] = false;
4037
4038      if ($(this.tip).hasClass(ClassName$6.FADE)) {
4039        var transitionDuration = Util.getTransitionDurationFromElement(tip);
4040        $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
4041      } else {
4042        complete();
4043      }
4044
4045      this._hoverState = '';
4046    };
4047
4048    _proto.update = function update() {
4049      if (this._popper !== null) {
4050        this._popper.scheduleUpdate();
4051      }
4052    } // Protected
4053    ;
4054
4055    _proto.isWithContent = function isWithContent() {
4056      return Boolean(this.getTitle());
4057    };
4058
4059    _proto.addAttachmentClass = function addAttachmentClass(attachment) {
4060      $(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
4061    };
4062
4063    _proto.getTipElement = function getTipElement() {
4064      this.tip = this.tip || $(this.config.template)[0];
4065      return this.tip;
4066    };
4067
4068    _proto.setContent = function setContent() {
4069      var tip = this.getTipElement();
4070      this.setElementContent($(tip.querySelectorAll(Selector$6.TOOLTIP_INNER)), this.getTitle());
4071      $(tip).removeClass(ClassName$6.FADE + " " + ClassName$6.SHOW);
4072    };
4073
4074    _proto.setElementContent = function setElementContent($element, content) {
4075      if (typeof content === 'object' && (content.nodeType || content.jquery)) {
4076        // Content is a DOM node or a jQuery
4077        if (this.config.html) {
4078          if (!$(content).parent().is($element)) {
4079            $element.empty().append(content);
4080          }
4081        } else {
4082          $element.text($(content).text());
4083        }
4084
4085        return;
4086      }
4087
4088      if (this.config.html) {
4089        if (this.config.sanitize) {
4090          content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn);
4091        }
4092
4093        $element.html(content);
4094      } else {
4095        $element.text(content);
4096      }
4097    };
4098
4099    _proto.getTitle = function getTitle() {
4100      var title = this.element.getAttribute('data-original-title');
4101
4102      if (!title) {
4103        title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
4104      }
4105
4106      return title;
4107    } // Private
4108    ;
4109
4110    _proto._getOffset = function _getOffset() {
4111      var _this3 = this;
4112
4113      var offset = {};
4114
4115      if (typeof this.config.offset === 'function') {
4116        offset.fn = function (data) {
4117          data.offsets = _objectSpread({}, data.offsets, _this3.config.offset(data.offsets, _this3.element) || {});
4118          return data;
4119        };
4120      } else {
4121        offset.offset = this.config.offset;
4122      }
4123
4124      return offset;
4125    };
4126
4127    _proto._getContainer = function _getContainer() {
4128      if (this.config.container === false) {
4129        return document.body;
4130      }
4131
4132      if (Util.isElement(this.config.container)) {
4133        return $(this.config.container);
4134      }
4135
4136      return $(document).find(this.config.container);
4137    };
4138
4139    _proto._getAttachment = function _getAttachment(placement) {
4140      return AttachmentMap$1[placement.toUpperCase()];
4141    };
4142
4143    _proto._setListeners = function _setListeners() {
4144      var _this4 = this;
4145
4146      var triggers = this.config.trigger.split(' ');
4147      triggers.forEach(function (trigger) {
4148        if (trigger === 'click') {
4149          $(_this4.element).on(_this4.constructor.Event.CLICK, _this4.config.selector, function (event) {
4150            return _this4.toggle(event);
4151          });
4152        } else if (trigger !== Trigger.MANUAL) {
4153          var eventIn = trigger === Trigger.HOVER ? _this4.constructor.Event.MOUSEENTER : _this4.constructor.Event.FOCUSIN;
4154          var eventOut = trigger === Trigger.HOVER ? _this4.constructor.Event.MOUSELEAVE : _this4.constructor.Event.FOCUSOUT;
4155          $(_this4.element).on(eventIn, _this4.config.selector, function (event) {
4156            return _this4._enter(event);
4157          }).on(eventOut, _this4.config.selector, function (event) {
4158            return _this4._leave(event);
4159          });
4160        }
4161      });
4162      $(this.element).closest('.modal').on('hide.bs.modal', function () {
4163        if (_this4.element) {
4164          _this4.hide();
4165        }
4166      });
4167
4168      if (this.config.selector) {
4169        this.config = _objectSpread({}, this.config, {
4170          trigger: 'manual',
4171          selector: ''
4172        });
4173      } else {
4174        this._fixTitle();
4175      }
4176    };
4177
4178    _proto._fixTitle = function _fixTitle() {
4179      var titleType = typeof this.element.getAttribute('data-original-title');
4180
4181      if (this.element.getAttribute('title') || titleType !== 'string') {
4182        this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
4183        this.element.setAttribute('title', '');
4184      }
4185    };
4186
4187    _proto._enter = function _enter(event, context) {
4188      var dataKey = this.constructor.DATA_KEY;
4189      context = context || $(event.currentTarget).data(dataKey);
4190
4191      if (!context) {
4192        context = new this.constructor(event.currentTarget, this._getDelegateConfig());
4193        $(event.currentTarget).data(dataKey, context);
4194      }
4195
4196      if (event) {
4197        context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
4198      }
4199
4200      if ($(context.getTipElement()).hasClass(ClassName$6.SHOW) || context._hoverState === HoverState.SHOW) {
4201        context._hoverState = HoverState.SHOW;
4202        return;
4203      }
4204
4205      clearTimeout(context._timeout);
4206      context._hoverState = HoverState.SHOW;
4207
4208      if (!context.config.delay || !context.config.delay.show) {
4209        context.show();
4210        return;
4211      }
4212
4213      context._timeout = setTimeout(function () {
4214        if (context._hoverState === HoverState.SHOW) {
4215          context.show();
4216        }
4217      }, context.config.delay.show);
4218    };
4219
4220    _proto._leave = function _leave(event, context) {
4221      var dataKey = this.constructor.DATA_KEY;
4222      context = context || $(event.currentTarget).data(dataKey);
4223
4224      if (!context) {
4225        context = new this.constructor(event.currentTarget, this._getDelegateConfig());
4226        $(event.currentTarget).data(dataKey, context);
4227      }
4228
4229      if (event) {
4230        context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
4231      }
4232
4233      if (context._isWithActiveTrigger()) {
4234        return;
4235      }
4236
4237      clearTimeout(context._timeout);
4238      context._hoverState = HoverState.OUT;
4239
4240      if (!context.config.delay || !context.config.delay.hide) {
4241        context.hide();
4242        return;
4243      }
4244
4245      context._timeout = setTimeout(function () {
4246        if (context._hoverState === HoverState.OUT) {
4247          context.hide();
4248        }
4249      }, context.config.delay.hide);
4250    };
4251
4252    _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
4253      for (var trigger in this._activeTrigger) {
4254        if (this._activeTrigger[trigger]) {
4255          return true;
4256        }
4257      }
4258
4259      return false;
4260    };
4261
4262    _proto._getConfig = function _getConfig(config) {
4263      var dataAttributes = $(this.element).data();
4264      Object.keys(dataAttributes).forEach(function (dataAttr) {
4265        if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) {
4266          delete dataAttributes[dataAttr];
4267        }
4268      });
4269      config = _objectSpread({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {});
4270
4271      if (typeof config.delay === 'number') {
4272        config.delay = {
4273          show: config.delay,
4274          hide: config.delay
4275        };
4276      }
4277
4278      if (typeof config.title === 'number') {
4279        config.title = config.title.toString();
4280      }
4281
4282      if (typeof config.content === 'number') {
4283        config.content = config.content.toString();
4284      }
4285
4286      Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType);
4287
4288      if (config.sanitize) {
4289        config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn);
4290      }
4291
4292      return config;
4293    };
4294
4295    _proto._getDelegateConfig = function _getDelegateConfig() {
4296      var config = {};
4297
4298      if (this.config) {
4299        for (var key in this.config) {
4300          if (this.constructor.Default[key] !== this.config[key]) {
4301            config[key] = this.config[key];
4302          }
4303        }
4304      }
4305
4306      return config;
4307    };
4308
4309    _proto._cleanTipClass = function _cleanTipClass() {
4310      var $tip = $(this.getTipElement());
4311      var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
4312
4313      if (tabClass !== null && tabClass.length) {
4314        $tip.removeClass(tabClass.join(''));
4315      }
4316    };
4317
4318    _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
4319      var popperInstance = popperData.instance;
4320      this.tip = popperInstance.popper;
4321
4322      this._cleanTipClass();
4323
4324      this.addAttachmentClass(this._getAttachment(popperData.placement));
4325    };
4326
4327    _proto._fixTransition = function _fixTransition() {
4328      var tip = this.getTipElement();
4329      var initConfigAnimation = this.config.animation;
4330
4331      if (tip.getAttribute('x-placement') !== null) {
4332        return;
4333      }
4334
4335      $(tip).removeClass(ClassName$6.FADE);
4336      this.config.animation = false;
4337      this.hide();
4338      this.show();
4339      this.config.animation = initConfigAnimation;
4340    } // Static
4341    ;
4342
4343    Tooltip._jQueryInterface = function _jQueryInterface(config) {
4344      return this.each(function () {
4345        var data = $(this).data(DATA_KEY$6);
4346
4347        var _config = typeof config === 'object' && config;
4348
4349        if (!data && /dispose|hide/.test(config)) {
4350          return;
4351        }
4352
4353        if (!data) {
4354          data = new Tooltip(this, _config);
4355          $(this).data(DATA_KEY$6, data);
4356        }
4357
4358        if (typeof config === 'string') {
4359          if (typeof data[config] === 'undefined') {
4360            throw new TypeError("No method named \"" + config + "\"");
4361          }
4362
4363          data[config]();
4364        }
4365      });
4366    };
4367
4368    _createClass(Tooltip, null, [{
4369      key: "VERSION",
4370      get: function get() {
4371        return VERSION$6;
4372      }
4373    }, {
4374      key: "Default",
4375      get: function get() {
4376        return Default$4;
4377      }
4378    }, {
4379      key: "NAME",
4380      get: function get() {
4381        return NAME$6;
4382      }
4383    }, {
4384      key: "DATA_KEY",
4385      get: function get() {
4386        return DATA_KEY$6;
4387      }
4388    }, {
4389      key: "Event",
4390      get: function get() {
4391        return Event$6;
4392      }
4393    }, {
4394      key: "EVENT_KEY",
4395      get: function get() {
4396        return EVENT_KEY$6;
4397      }
4398    }, {
4399      key: "DefaultType",
4400      get: function get() {
4401        return DefaultType$4;
4402      }
4403    }]);
4404
4405    return Tooltip;
4406  }();
4407  /**
4408   * ------------------------------------------------------------------------
4409   * jQuery
4410   * ------------------------------------------------------------------------
4411   */
4412
4413
4414  $.fn[NAME$6] = Tooltip._jQueryInterface;
4415  $.fn[NAME$6].Constructor = Tooltip;
4416
4417  $.fn[NAME$6].noConflict = function () {
4418    $.fn[NAME$6] = JQUERY_NO_CONFLICT$6;
4419    return Tooltip._jQueryInterface;
4420  };
4421
4422  /**
4423   * ------------------------------------------------------------------------
4424   * Constants
4425   * ------------------------------------------------------------------------
4426   */
4427
4428  var NAME$7 = 'popover';
4429  var VERSION$7 = '4.3.1';
4430  var DATA_KEY$7 = 'bs.popover';
4431  var EVENT_KEY$7 = "." + DATA_KEY$7;
4432  var JQUERY_NO_CONFLICT$7 = $.fn[NAME$7];
4433  var CLASS_PREFIX$1 = 'bs-popover';
4434  var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g');
4435
4436  var Default$5 = _objectSpread({}, Tooltip.Default, {
4437    placement: 'right',
4438    trigger: 'click',
4439    content: '',
4440    template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
4441  });
4442
4443  var DefaultType$5 = _objectSpread({}, Tooltip.DefaultType, {
4444    content: '(string|element|function)'
4445  });
4446
4447  var ClassName$7 = {
4448    FADE: 'fade',
4449    SHOW: 'show'
4450  };
4451  var Selector$7 = {
4452    TITLE: '.popover-header',
4453    CONTENT: '.popover-body'
4454  };
4455  var Event$7 = {
4456    HIDE: "hide" + EVENT_KEY$7,
4457    HIDDEN: "hidden" + EVENT_KEY$7,
4458    SHOW: "show" + EVENT_KEY$7,
4459    SHOWN: "shown" + EVENT_KEY$7,
4460    INSERTED: "inserted" + EVENT_KEY$7,
4461    CLICK: "click" + EVENT_KEY$7,
4462    FOCUSIN: "focusin" + EVENT_KEY$7,
4463    FOCUSOUT: "focusout" + EVENT_KEY$7,
4464    MOUSEENTER: "mouseenter" + EVENT_KEY$7,
4465    MOUSELEAVE: "mouseleave" + EVENT_KEY$7
4466    /**
4467     * ------------------------------------------------------------------------
4468     * Class Definition
4469     * ------------------------------------------------------------------------
4470     */
4471
4472  };
4473
4474  var Popover =
4475  /*#__PURE__*/
4476  function (_Tooltip) {
4477    _inheritsLoose(Popover, _Tooltip);
4478
4479    function Popover() {
4480      return _Tooltip.apply(this, arguments) || this;
4481    }
4482
4483    var _proto = Popover.prototype;
4484
4485    // Overrides
4486    _proto.isWithContent = function isWithContent() {
4487      return this.getTitle() || this._getContent();
4488    };
4489
4490    _proto.addAttachmentClass = function addAttachmentClass(attachment) {
4491      $(this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment);
4492    };
4493
4494    _proto.getTipElement = function getTipElement() {
4495      this.tip = this.tip || $(this.config.template)[0];
4496      return this.tip;
4497    };
4498
4499    _proto.setContent = function setContent() {
4500      var $tip = $(this.getTipElement()); // We use append for html objects to maintain js events
4501
4502      this.setElementContent($tip.find(Selector$7.TITLE), this.getTitle());
4503
4504      var content = this._getContent();
4505
4506      if (typeof content === 'function') {
4507        content = content.call(this.element);
4508      }
4509
4510      this.setElementContent($tip.find(Selector$7.CONTENT), content);
4511      $tip.removeClass(ClassName$7.FADE + " " + ClassName$7.SHOW);
4512    } // Private
4513    ;
4514
4515    _proto._getContent = function _getContent() {
4516      return this.element.getAttribute('data-content') || this.config.content;
4517    };
4518
4519    _proto._cleanTipClass = function _cleanTipClass() {
4520      var $tip = $(this.getTipElement());
4521      var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1);
4522
4523      if (tabClass !== null && tabClass.length > 0) {
4524        $tip.removeClass(tabClass.join(''));
4525      }
4526    } // Static
4527    ;
4528
4529    Popover._jQueryInterface = function _jQueryInterface(config) {
4530      return this.each(function () {
4531        var data = $(this).data(DATA_KEY$7);
4532
4533        var _config = typeof config === 'object' ? config : null;
4534
4535        if (!data && /dispose|hide/.test(config)) {
4536          return;
4537        }
4538
4539        if (!data) {
4540          data = new Popover(this, _config);
4541          $(this).data(DATA_KEY$7, data);
4542        }
4543
4544        if (typeof config === 'string') {
4545          if (typeof data[config] === 'undefined') {
4546            throw new TypeError("No method named \"" + config + "\"");
4547          }
4548
4549          data[config]();
4550        }
4551      });
4552    };
4553
4554    _createClass(Popover, null, [{
4555      key: "VERSION",
4556      // Getters
4557      get: function get() {
4558        return VERSION$7;
4559      }
4560    }, {
4561      key: "Default",
4562      get: function get() {
4563        return Default$5;
4564      }
4565    }, {
4566      key: "NAME",
4567      get: function get() {
4568        return NAME$7;
4569      }
4570    }, {
4571      key: "DATA_KEY",
4572      get: function get() {
4573        return DATA_KEY$7;
4574      }
4575    }, {
4576      key: "Event",
4577      get: function get() {
4578        return Event$7;
4579      }
4580    }, {
4581      key: "EVENT_KEY",
4582      get: function get() {
4583        return EVENT_KEY$7;
4584      }
4585    }, {
4586      key: "DefaultType",
4587      get: function get() {
4588        return DefaultType$5;
4589      }
4590    }]);
4591
4592    return Popover;
4593  }(Tooltip);
4594  /**
4595   * ------------------------------------------------------------------------
4596   * jQuery
4597   * ------------------------------------------------------------------------
4598   */
4599
4600
4601  $.fn[NAME$7] = Popover._jQueryInterface;
4602  $.fn[NAME$7].Constructor = Popover;
4603
4604  $.fn[NAME$7].noConflict = function () {
4605    $.fn[NAME$7] = JQUERY_NO_CONFLICT$7;
4606    return Popover._jQueryInterface;
4607  };
4608
4609  /**
4610   * ------------------------------------------------------------------------
4611   * Constants
4612   * ------------------------------------------------------------------------
4613   */
4614
4615  var NAME$8 = 'scrollspy';
4616  var VERSION$8 = '4.3.1';
4617  var DATA_KEY$8 = 'bs.scrollspy';
4618  var EVENT_KEY$8 = "." + DATA_KEY$8;
4619  var DATA_API_KEY$6 = '.data-api';
4620  var JQUERY_NO_CONFLICT$8 = $.fn[NAME$8];
4621  var Default$6 = {
4622    offset: 10,
4623    method: 'auto',
4624    target: ''
4625  };
4626  var DefaultType$6 = {
4627    offset: 'number',
4628    method: 'string',
4629    target: '(string|element)'
4630  };
4631  var Event$8 = {
4632    ACTIVATE: "activate" + EVENT_KEY$8,
4633    SCROLL: "scroll" + EVENT_KEY$8,
4634    LOAD_DATA_API: "load" + EVENT_KEY$8 + DATA_API_KEY$6
4635  };
4636  var ClassName$8 = {
4637    DROPDOWN_ITEM: 'dropdown-item',
4638    DROPDOWN_MENU: 'dropdown-menu',
4639    ACTIVE: 'active'
4640  };
4641  var Selector$8 = {
4642    DATA_SPY: '[data-spy="scroll"]',
4643    ACTIVE: '.active',
4644    NAV_LIST_GROUP: '.nav, .list-group',
4645    NAV_LINKS: '.nav-link',
4646    NAV_ITEMS: '.nav-item',
4647    LIST_ITEMS: '.list-group-item',
4648    DROPDOWN: '.dropdown',
4649    DROPDOWN_ITEMS: '.dropdown-item',
4650    DROPDOWN_TOGGLE: '.dropdown-toggle'
4651  };
4652  var OffsetMethod = {
4653    OFFSET: 'offset',
4654    POSITION: 'position'
4655    /**
4656     * ------------------------------------------------------------------------
4657     * Class Definition
4658     * ------------------------------------------------------------------------
4659     */
4660
4661  };
4662
4663  var ScrollSpy =
4664  /*#__PURE__*/
4665  function () {
4666    function ScrollSpy(element, config) {
4667      var _this = this;
4668
4669      this._element = element;
4670      this._scrollElement = element.tagName === 'BODY' ? window : element;
4671      this._config = this._getConfig(config);
4672      this._selector = this._config.target + " " + Selector$8.NAV_LINKS + "," + (this._config.target + " " + Selector$8.LIST_ITEMS + ",") + (this._config.target + " " + Selector$8.DROPDOWN_ITEMS);
4673      this._offsets = [];
4674      this._targets = [];
4675      this._activeTarget = null;
4676      this._scrollHeight = 0;
4677      $(this._scrollElement).on(Event$8.SCROLL, function (event) {
4678        return _this._process(event);
4679      });
4680      this.refresh();
4681
4682      this._process();
4683    } // Getters
4684
4685
4686    var _proto = ScrollSpy.prototype;
4687
4688    // Public
4689    _proto.refresh = function refresh() {
4690      var _this2 = this;
4691
4692      var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
4693      var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
4694      var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
4695      this._offsets = [];
4696      this._targets = [];
4697      this._scrollHeight = this._getScrollHeight();
4698      var targets = [].slice.call(document.querySelectorAll(this._selector));
4699      targets.map(function (element) {
4700        var target;
4701        var targetSelector = Util.getSelectorFromElement(element);
4702
4703        if (targetSelector) {
4704          target = document.querySelector(targetSelector);
4705        }
4706
4707        if (target) {
4708          var targetBCR = target.getBoundingClientRect();
4709
4710          if (targetBCR.width || targetBCR.height) {
4711            // TODO (fat): remove sketch reliance on jQuery position/offset
4712            return [$(target)[offsetMethod]().top + offsetBase, targetSelector];
4713          }
4714        }
4715
4716        return null;
4717      }).filter(function (item) {
4718        return item;
4719      }).sort(function (a, b) {
4720        return a[0] - b[0];
4721      }).forEach(function (item) {
4722        _this2._offsets.push(item[0]);
4723
4724        _this2._targets.push(item[1]);
4725      });
4726    };
4727
4728    _proto.dispose = function dispose() {
4729      $.removeData(this._element, DATA_KEY$8);
4730      $(this._scrollElement).off(EVENT_KEY$8);
4731      this._element = null;
4732      this._scrollElement = null;
4733      this._config = null;
4734      this._selector = null;
4735      this._offsets = null;
4736      this._targets = null;
4737      this._activeTarget = null;
4738      this._scrollHeight = null;
4739    } // Private
4740    ;
4741
4742    _proto._getConfig = function _getConfig(config) {
4743      config = _objectSpread({}, Default$6, typeof config === 'object' && config ? config : {});
4744
4745      if (typeof config.target !== 'string') {
4746        var id = $(config.target).attr('id');
4747
4748        if (!id) {
4749          id = Util.getUID(NAME$8);
4750          $(config.target).attr('id', id);
4751        }
4752
4753        config.target = "#" + id;
4754      }
4755
4756      Util.typeCheckConfig(NAME$8, config, DefaultType$6);
4757      return config;
4758    };
4759
4760    _proto._getScrollTop = function _getScrollTop() {
4761      return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
4762    };
4763
4764    _proto._getScrollHeight = function _getScrollHeight() {
4765      return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
4766    };
4767
4768    _proto._getOffsetHeight = function _getOffsetHeight() {
4769      return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
4770    };
4771
4772    _proto._process = function _process() {
4773      var scrollTop = this._getScrollTop() + this._config.offset;
4774
4775      var scrollHeight = this._getScrollHeight();
4776
4777      var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
4778
4779      if (this._scrollHeight !== scrollHeight) {
4780        this.refresh();
4781      }
4782
4783      if (scrollTop >= maxScroll) {
4784        var target = this._targets[this._targets.length - 1];
4785
4786        if (this._activeTarget !== target) {
4787          this._activate(target);
4788        }
4789
4790        return;
4791      }
4792
4793      if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
4794        this._activeTarget = null;
4795
4796        this._clear();
4797
4798        return;
4799      }
4800
4801      var offsetLength = this._offsets.length;
4802
4803      for (var i = offsetLength; i--;) {
4804        var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
4805
4806        if (isActiveTarget) {
4807          this._activate(this._targets[i]);
4808        }
4809      }
4810    };
4811
4812    _proto._activate = function _activate(target) {
4813      this._activeTarget = target;
4814
4815      this._clear();
4816
4817      var queries = this._selector.split(',').map(function (selector) {
4818        return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]";
4819      });
4820
4821      var $link = $([].slice.call(document.querySelectorAll(queries.join(','))));
4822
4823      if ($link.hasClass(ClassName$8.DROPDOWN_ITEM)) {
4824        $link.closest(Selector$8.DROPDOWN).find(Selector$8.DROPDOWN_TOGGLE).addClass(ClassName$8.ACTIVE);
4825        $link.addClass(ClassName$8.ACTIVE);
4826      } else {
4827        // Set triggered link as active
4828        $link.addClass(ClassName$8.ACTIVE); // Set triggered links parents as active
4829        // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
4830
4831        $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_LINKS + ", " + Selector$8.LIST_ITEMS).addClass(ClassName$8.ACTIVE); // Handle special case when .nav-link is inside .nav-item
4832
4833        $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_ITEMS).children(Selector$8.NAV_LINKS).addClass(ClassName$8.ACTIVE);
4834      }
4835
4836      $(this._scrollElement).trigger(Event$8.ACTIVATE, {
4837        relatedTarget: target
4838      });
4839    };
4840
4841    _proto._clear = function _clear() {
4842      [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) {
4843        return node.classList.contains(ClassName$8.ACTIVE);
4844      }).forEach(function (node) {
4845        return node.classList.remove(ClassName$8.ACTIVE);
4846      });
4847    } // Static
4848    ;
4849
4850    ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
4851      return this.each(function () {
4852        var data = $(this).data(DATA_KEY$8);
4853
4854        var _config = typeof config === 'object' && config;
4855
4856        if (!data) {
4857          data = new ScrollSpy(this, _config);
4858          $(this).data(DATA_KEY$8, data);
4859        }
4860
4861        if (typeof config === 'string') {
4862          if (typeof data[config] === 'undefined') {
4863            throw new TypeError("No method named \"" + config + "\"");
4864          }
4865
4866          data[config]();
4867        }
4868      });
4869    };
4870
4871    _createClass(ScrollSpy, null, [{
4872      key: "VERSION",
4873      get: function get() {
4874        return VERSION$8;
4875      }
4876    }, {
4877      key: "Default",
4878      get: function get() {
4879        return Default$6;
4880      }
4881    }]);
4882
4883    return ScrollSpy;
4884  }();
4885  /**
4886   * ------------------------------------------------------------------------
4887   * Data Api implementation
4888   * ------------------------------------------------------------------------
4889   */
4890
4891
4892  $(window).on(Event$8.LOAD_DATA_API, function () {
4893    var scrollSpys = [].slice.call(document.querySelectorAll(Selector$8.DATA_SPY));
4894    var scrollSpysLength = scrollSpys.length;
4895
4896    for (var i = scrollSpysLength; i--;) {
4897      var $spy = $(scrollSpys[i]);
4898
4899      ScrollSpy._jQueryInterface.call($spy, $spy.data());
4900    }
4901  });
4902  /**
4903   * ------------------------------------------------------------------------
4904   * jQuery
4905   * ------------------------------------------------------------------------
4906   */
4907
4908  $.fn[NAME$8] = ScrollSpy._jQueryInterface;
4909  $.fn[NAME$8].Constructor = ScrollSpy;
4910
4911  $.fn[NAME$8].noConflict = function () {
4912    $.fn[NAME$8] = JQUERY_NO_CONFLICT$8;
4913    return ScrollSpy._jQueryInterface;
4914  };
4915
4916  /**
4917   * ------------------------------------------------------------------------
4918   * Constants
4919   * ------------------------------------------------------------------------
4920   */
4921
4922  var NAME$9 = 'tab';
4923  var VERSION$9 = '4.3.1';
4924  var DATA_KEY$9 = 'bs.tab';
4925  var EVENT_KEY$9 = "." + DATA_KEY$9;
4926  var DATA_API_KEY$7 = '.data-api';
4927  var JQUERY_NO_CONFLICT$9 = $.fn[NAME$9];
4928  var Event$9 = {
4929    HIDE: "hide" + EVENT_KEY$9,
4930    HIDDEN: "hidden" + EVENT_KEY$9,
4931    SHOW: "show" + EVENT_KEY$9,
4932    SHOWN: "shown" + EVENT_KEY$9,
4933    CLICK_DATA_API: "click" + EVENT_KEY$9 + DATA_API_KEY$7
4934  };
4935  var ClassName$9 = {
4936    DROPDOWN_MENU: 'dropdown-menu',
4937    ACTIVE: 'active',
4938    DISABLED: 'disabled',
4939    FADE: 'fade',
4940    SHOW: 'show'
4941  };
4942  var Selector$9 = {
4943    DROPDOWN: '.dropdown',
4944    NAV_LIST_GROUP: '.nav, .list-group',
4945    ACTIVE: '.active',
4946    ACTIVE_UL: '> li > .active',
4947    DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
4948    DROPDOWN_TOGGLE: '.dropdown-toggle',
4949    DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
4950    /**
4951     * ------------------------------------------------------------------------
4952     * Class Definition
4953     * ------------------------------------------------------------------------
4954     */
4955
4956  };
4957
4958  var Tab =
4959  /*#__PURE__*/
4960  function () {
4961    function Tab(element) {
4962      this._element = element;
4963    } // Getters
4964
4965
4966    var _proto = Tab.prototype;
4967
4968    // Public
4969    _proto.show = function show() {
4970      var _this = this;
4971
4972      if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $(this._element).hasClass(ClassName$9.ACTIVE) || $(this._element).hasClass(ClassName$9.DISABLED)) {
4973        return;
4974      }
4975
4976      var target;
4977      var previous;
4978      var listElement = $(this._element).closest(Selector$9.NAV_LIST_GROUP)[0];
4979      var selector = Util.getSelectorFromElement(this._element);
4980
4981      if (listElement) {
4982        var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? Selector$9.ACTIVE_UL : Selector$9.ACTIVE;
4983        previous = $.makeArray($(listElement).find(itemSelector));
4984        previous = previous[previous.length - 1];
4985      }
4986
4987      var hideEvent = $.Event(Event$9.HIDE, {
4988        relatedTarget: this._element
4989      });
4990      var showEvent = $.Event(Event$9.SHOW, {
4991        relatedTarget: previous
4992      });
4993
4994      if (previous) {
4995        $(previous).trigger(hideEvent);
4996      }
4997
4998      $(this._element).trigger(showEvent);
4999
5000      if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
5001        return;
5002      }
5003
5004      if (selector) {
5005        target = document.querySelector(selector);
5006      }
5007
5008      this._activate(this._element, listElement);
5009
5010      var complete = function complete() {
5011        var hiddenEvent = $.Event(Event$9.HIDDEN, {
5012          relatedTarget: _this._element
5013        });
5014        var shownEvent = $.Event(Event$9.SHOWN, {
5015          relatedTarget: previous
5016        });
5017        $(previous).trigger(hiddenEvent);
5018        $(_this._element).trigger(shownEvent);
5019      };
5020
5021      if (target) {
5022        this._activate(target, target.parentNode, complete);
5023      } else {
5024        complete();
5025      }
5026    };
5027
5028    _proto.dispose = function dispose() {
5029      $.removeData(this._element, DATA_KEY$9);
5030      this._element = null;
5031    } // Private
5032    ;
5033
5034    _proto._activate = function _activate(element, container, callback) {
5035      var _this2 = this;
5036
5037      var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $(container).find(Selector$9.ACTIVE_UL) : $(container).children(Selector$9.ACTIVE);
5038      var active = activeElements[0];
5039      var isTransitioning = callback && active && $(active).hasClass(ClassName$9.FADE);
5040
5041      var complete = function complete() {
5042        return _this2._transitionComplete(element, active, callback);
5043      };
5044
5045      if (active && isTransitioning) {
5046        var transitionDuration = Util.getTransitionDurationFromElement(active);
5047        $(active).removeClass(ClassName$9.SHOW).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
5048      } else {
5049        complete();
5050      }
5051    };
5052
5053    _proto._transitionComplete = function _transitionComplete(element, active, callback) {
5054      if (active) {
5055        $(active).removeClass(ClassName$9.ACTIVE);
5056        var dropdownChild = $(active.parentNode).find(Selector$9.DROPDOWN_ACTIVE_CHILD)[0];
5057
5058        if (dropdownChild) {
5059          $(dropdownChild).removeClass(ClassName$9.ACTIVE);
5060        }
5061
5062        if (active.getAttribute('role') === 'tab') {
5063          active.setAttribute('aria-selected', false);
5064        }
5065      }
5066
5067      $(element).addClass(ClassName$9.ACTIVE);
5068
5069      if (element.getAttribute('role') === 'tab') {
5070        element.setAttribute('aria-selected', true);
5071      }
5072
5073      Util.reflow(element);
5074
5075      if (element.classList.contains(ClassName$9.FADE)) {
5076        element.classList.add(ClassName$9.SHOW);
5077      }
5078
5079      if (element.parentNode && $(element.parentNode).hasClass(ClassName$9.DROPDOWN_MENU)) {
5080        var dropdownElement = $(element).closest(Selector$9.DROPDOWN)[0];
5081
5082        if (dropdownElement) {
5083          var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector$9.DROPDOWN_TOGGLE));
5084          $(dropdownToggleList).addClass(ClassName$9.ACTIVE);
5085        }
5086
5087        element.setAttribute('aria-expanded', true);
5088      }
5089
5090      if (callback) {
5091        callback();
5092      }
5093    } // Static
5094    ;
5095
5096    Tab._jQueryInterface = function _jQueryInterface(config) {
5097      return this.each(function () {
5098        var $this = $(this);
5099        var data = $this.data(DATA_KEY$9);
5100
5101        if (!data) {
5102          data = new Tab(this);
5103          $this.data(DATA_KEY$9, data);
5104        }
5105
5106        if (typeof config === 'string') {
5107          if (typeof data[config] === 'undefined') {
5108            throw new TypeError("No method named \"" + config + "\"");
5109          }
5110
5111          data[config]();
5112        }
5113      });
5114    };
5115
5116    _createClass(Tab, null, [{
5117      key: "VERSION",
5118      get: function get() {
5119        return VERSION$9;
5120      }
5121    }]);
5122
5123    return Tab;
5124  }();
5125  /**
5126   * ------------------------------------------------------------------------
5127   * Data Api implementation
5128   * ------------------------------------------------------------------------
5129   */
5130
5131
5132  $(document).on(Event$9.CLICK_DATA_API, Selector$9.DATA_TOGGLE, function (event) {
5133    event.preventDefault();
5134
5135    Tab._jQueryInterface.call($(this), 'show');
5136  });
5137  /**
5138   * ------------------------------------------------------------------------
5139   * jQuery
5140   * ------------------------------------------------------------------------
5141   */
5142
5143  $.fn[NAME$9] = Tab._jQueryInterface;
5144  $.fn[NAME$9].Constructor = Tab;
5145
5146  $.fn[NAME$9].noConflict = function () {
5147    $.fn[NAME$9] = JQUERY_NO_CONFLICT$9;
5148    return Tab._jQueryInterface;
5149  };
5150
5151  /**
5152   * ------------------------------------------------------------------------
5153   * Constants
5154   * ------------------------------------------------------------------------
5155   */
5156
5157  var NAME$a = 'toast';
5158  var VERSION$a = '4.3.1';
5159  var DATA_KEY$a = 'bs.toast';
5160  var EVENT_KEY$a = "." + DATA_KEY$a;
5161  var JQUERY_NO_CONFLICT$a = $.fn[NAME$a];
5162  var Event$a = {
5163    CLICK_DISMISS: "click.dismiss" + EVENT_KEY$a,
5164    HIDE: "hide" + EVENT_KEY$a,
5165    HIDDEN: "hidden" + EVENT_KEY$a,
5166    SHOW: "show" + EVENT_KEY$a,
5167    SHOWN: "shown" + EVENT_KEY$a
5168  };
5169  var ClassName$a = {
5170    FADE: 'fade',
5171    HIDE: 'hide',
5172    SHOW: 'show',
5173    SHOWING: 'showing'
5174  };
5175  var DefaultType$7 = {
5176    animation: 'boolean',
5177    autohide: 'boolean',
5178    delay: 'number'
5179  };
5180  var Default$7 = {
5181    animation: true,
5182    autohide: true,
5183    delay: 500
5184  };
5185  var Selector$a = {
5186    DATA_DISMISS: '[data-dismiss="toast"]'
5187    /**
5188     * ------------------------------------------------------------------------
5189     * Class Definition
5190     * ------------------------------------------------------------------------
5191     */
5192
5193  };
5194
5195  var Toast =
5196  /*#__PURE__*/
5197  function () {
5198    function Toast(element, config) {
5199      this._element = element;
5200      this._config = this._getConfig(config);
5201      this._timeout = null;
5202
5203      this._setListeners();
5204    } // Getters
5205
5206
5207    var _proto = Toast.prototype;
5208
5209    // Public
5210    _proto.show = function show() {
5211      var _this = this;
5212
5213      $(this._element).trigger(Event$a.SHOW);
5214
5215      if (this._config.animation) {
5216        this._element.classList.add(ClassName$a.FADE);
5217      }
5218
5219      var complete = function complete() {
5220        _this._element.classList.remove(ClassName$a.SHOWING);
5221
5222        _this._element.classList.add(ClassName$a.SHOW);
5223
5224        $(_this._element).trigger(Event$a.SHOWN);
5225
5226        if (_this._config.autohide) {
5227          _this.hide();
5228        }
5229      };
5230
5231      this._element.classList.remove(ClassName$a.HIDE);
5232
5233      this._element.classList.add(ClassName$a.SHOWING);
5234
5235      if (this._config.animation) {
5236        var transitionDuration = Util.getTransitionDurationFromElement(this._element);
5237        $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
5238      } else {
5239        complete();
5240      }
5241    };
5242
5243    _proto.hide = function hide(withoutTimeout) {
5244      var _this2 = this;
5245
5246      if (!this._element.classList.contains(ClassName$a.SHOW)) {
5247        return;
5248      }
5249
5250      $(this._element).trigger(Event$a.HIDE);
5251
5252      if (withoutTimeout) {
5253        this._close();
5254      } else {
5255        this._timeout = setTimeout(function () {
5256          _this2._close();
5257        }, this._config.delay);
5258      }
5259    };
5260
5261    _proto.dispose = function dispose() {
5262      clearTimeout(this._timeout);
5263      this._timeout = null;
5264
5265      if (this._element.classList.contains(ClassName$a.SHOW)) {
5266        this._element.classList.remove(ClassName$a.SHOW);
5267      }
5268
5269      $(this._element).off(Event$a.CLICK_DISMISS);
5270      $.removeData(this._element, DATA_KEY$a);
5271      this._element = null;
5272      this._config = null;
5273    } // Private
5274    ;
5275
5276    _proto._getConfig = function _getConfig(config) {
5277      config = _objectSpread({}, Default$7, $(this._element).data(), typeof config === 'object' && config ? config : {});
5278      Util.typeCheckConfig(NAME$a, config, this.constructor.DefaultType);
5279      return config;
5280    };
5281
5282    _proto._setListeners = function _setListeners() {
5283      var _this3 = this;
5284
5285      $(this._element).on(Event$a.CLICK_DISMISS, Selector$a.DATA_DISMISS, function () {
5286        return _this3.hide(true);
5287      });
5288    };
5289
5290    _proto._close = function _close() {
5291      var _this4 = this;
5292
5293      var complete = function complete() {
5294        _this4._element.classList.add(ClassName$a.HIDE);
5295
5296        $(_this4._element).trigger(Event$a.HIDDEN);
5297      };
5298
5299      this._element.classList.remove(ClassName$a.SHOW);
5300
5301      if (this._config.animation) {
5302        var transitionDuration = Util.getTransitionDurationFromElement(this._element);
5303        $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
5304      } else {
5305        complete();
5306      }
5307    } // Static
5308    ;
5309
5310    Toast._jQueryInterface = function _jQueryInterface(config) {
5311      return this.each(function () {
5312        var $element = $(this);
5313        var data = $element.data(DATA_KEY$a);
5314
5315        var _config = typeof config === 'object' && config;
5316
5317        if (!data) {
5318          data = new Toast(this, _config);
5319          $element.data(DATA_KEY$a, data);
5320        }
5321
5322        if (typeof config === 'string') {
5323          if (typeof data[config] === 'undefined') {
5324            throw new TypeError("No method named \"" + config + "\"");
5325          }
5326
5327          data[config](this);
5328        }
5329      });
5330    };
5331
5332    _createClass(Toast, null, [{
5333      key: "VERSION",
5334      get: function get() {
5335        return VERSION$a;
5336      }
5337    }, {
5338      key: "DefaultType",
5339      get: function get() {
5340        return DefaultType$7;
5341      }
5342    }, {
5343      key: "Default",
5344      get: function get() {
5345        return Default$7;
5346      }
5347    }]);
5348
5349    return Toast;
5350  }();
5351  /**
5352   * ------------------------------------------------------------------------
5353   * jQuery
5354   * ------------------------------------------------------------------------
5355   */
5356
5357
5358  $.fn[NAME$a] = Toast._jQueryInterface;
5359  $.fn[NAME$a].Constructor = Toast;
5360
5361  $.fn[NAME$a].noConflict = function () {
5362    $.fn[NAME$a] = JQUERY_NO_CONFLICT$a;
5363    return Toast._jQueryInterface;
5364  };
5365
5366  /**
5367   * --------------------------------------------------------------------------
5368   * Bootstrap (v4.3.1): index.js
5369   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
5370   * --------------------------------------------------------------------------
5371   */
5372
5373  (function () {
5374    if (typeof $ === 'undefined') {
5375      throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
5376    }
5377
5378    var version = $.fn.jquery.split(' ')[0].split('.');
5379    var minMajor = 1;
5380    var ltMajor = 2;
5381    var minMinor = 9;
5382    var minPatch = 1;
5383    var maxMajor = 4;
5384
5385    if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
5386      throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
5387    }
5388  })();
5389
5390  exports.Util = Util;
5391  exports.Alert = Alert;
5392  exports.Button = Button;
5393  exports.Carousel = Carousel;
5394  exports.Collapse = Collapse;
5395  exports.Dropdown = Dropdown;
5396  exports.Modal = Modal;
5397  exports.Popover = Popover;
5398  exports.Scrollspy = ScrollSpy;
5399  exports.Tab = Tab;
5400  exports.Toast = Toast;
5401  exports.Tooltip = Tooltip;
5402
5403  Object.defineProperty(exports, '__esModule', { value: true });
5404
5405}));
5406//# sourceMappingURL=bootstrap.js.map
5407
5408
5409/***/ }),
5410