tools/side_chain_tool/web/node_modules/bootstrap/dist/js/bootstrap.js

   1 /*!
   2   * Bootstrap v4.1.3 (https://getbootstrap.com/)
   3   * Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
   4   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   5   */
   6 (function (global, factory) {
   7   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) :
   8   typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) :
   9   (factory((global.bootstrap = {}),global.jQuery,global.Popper));
  10 }(this, (function (exports,$,Popper) { 'use strict';
  11
  12   $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
  13   Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
  14
  15   function _defineProperties(target, props) {
  16     for (var i = 0; i < props.length; i++) {
  17       var descriptor = props[i];
  18       descriptor.enumerable = descriptor.enumerable || false;
  19       descriptor.configurable = true;
  20       if ("value" in descriptor) descriptor.writable = true;
  21       Object.defineProperty(target, descriptor.key, descriptor);
  22     }
  23   }
  24
  25   function _createClass(Constructor, protoProps, staticProps) {
  26     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  27     if (staticProps) _defineProperties(Constructor, staticProps);
  28     return Constructor;
  29   }
  30
  31   function _defineProperty(obj, key, value) {
  32     if (key in obj) {
  33       Object.defineProperty(obj, key, {
  34         value: value,
  35         enumerable: true,
  36         configurable: true,
  37         writable: true
  38       });
  39     } else {
  40       obj[key] = value;
  41     }
  42
  43     return obj;
  44   }
  45
  46   function _objectSpread(target) {
  47     for (var i = 1; i < arguments.length; i++) {
  48       var source = arguments[i] != null ? arguments[i] : {};
  49       var ownKeys = Object.keys(source);
  50
  51       if (typeof Object.getOwnPropertySymbols === 'function') {
  52         ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
  53           return Object.getOwnPropertyDescriptor(source, sym).enumerable;
  54         }));
  55       }
  56
  57       ownKeys.forEach(function (key) {
  58         _defineProperty(target, key, source[key]);
  59       });
  60     }
  61
  62     return target;
  63   }
  64
  65   function _inheritsLoose(subClass, superClass) {
  66     subClass.prototype = Object.create(superClass.prototype);
  67     subClass.prototype.constructor = subClass;
  68     subClass.__proto__ = superClass;
  69   }
  70
  71   /**
  72    * --------------------------------------------------------------------------
  73    * Bootstrap (v4.1.3): util.js
  74    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  75    * --------------------------------------------------------------------------
  76    */
  77
  78   var Util = function ($$$1) {
  79     /**
  80      * ------------------------------------------------------------------------
  81      * Private TransitionEnd Helpers
  82      * ------------------------------------------------------------------------
  83      */
  84     var TRANSITION_END = 'transitionend';
  85     var MAX_UID = 1000000;
  86     var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
  87
  88     function toType(obj) {
  89       return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
  90     }
  91
  92     function getSpecialTransitionEndEvent() {
  93       return {
  94         bindType: TRANSITION_END,
  95         delegateType: TRANSITION_END,
  96         handle: function handle(event) {
  97           if ($$$1(event.target).is(this)) {
  98             return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
  99           }
 100
 101           return undefined; // eslint-disable-line no-undefined
 102         }
 103       };
 104     }
 105
 106     function transitionEndEmulator(duration) {
 107       var _this = this;
 108
 109       var called = false;
 110       $$$1(this).one(Util.TRANSITION_END, function () {
 111         called = true;
 112       });
 113       setTimeout(function () {
 114         if (!called) {
 115           Util.triggerTransitionEnd(_this);
 116         }
 117       }, duration);
 118       return this;
 119     }
 120
 121     function setTransitionEndSupport() {
 122       $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
 123       $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
 124     }
 125     /**
 126      * --------------------------------------------------------------------------
 127      * Public Util Api
 128      * --------------------------------------------------------------------------
 129      */
 130
 131
 132     var Util = {
 133       TRANSITION_END: 'bsTransitionEnd',
 134       getUID: function getUID(prefix) {
 135         do {
 136           // eslint-disable-next-line no-bitwise
 137           prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
 138         } while (document.getElementById(prefix));
 139
 140         return prefix;
 141       },
 142       getSelectorFromElement: function getSelectorFromElement(element) {
 143         var selector = element.getAttribute('data-target');
 144
 145         if (!selector || selector === '#') {
 146           selector = element.getAttribute('href') || '';
 147         }
 148
 149         try {
 150           return document.querySelector(selector) ? selector : null;
 151         } catch (err) {
 152           return null;
 153         }
 154       },
 155       getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
 156         if (!element) {
 157           return 0;
 158         } // Get transition-duration of the element
 159
 160
 161         var transitionDuration = $$$1(element).css('transition-duration');
 162         var floatTransitionDuration = parseFloat(transitionDuration); // Return 0 if element or transition duration is not found
 163
 164         if (!floatTransitionDuration) {
 165           return 0;
 166         } // If multiple durations are defined, take the first
 167
 168
 169         transitionDuration = transitionDuration.split(',')[0];
 170         return parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER;
 171       },
 172       reflow: function reflow(element) {
 173         return element.offsetHeight;
 174       },
 175       triggerTransitionEnd: function triggerTransitionEnd(element) {
 176         $$$1(element).trigger(TRANSITION_END);
 177       },
 178       // TODO: Remove in v5
 179       supportsTransitionEnd: function supportsTransitionEnd() {
 180         return Boolean(TRANSITION_END);
 181       },
 182       isElement: function isElement(obj) {
 183         return (obj[0] || obj).nodeType;
 184       },
 185       typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
 186         for (var property in configTypes) {
 187           if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
 188             var expectedTypes = configTypes[property];
 189             var value = config[property];
 190             var valueType = value && Util.isElement(value) ? 'element' : toType(value);
 191
 192             if (!new RegExp(expectedTypes).test(valueType)) {
 193               throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
 194             }
 195           }
 196         }
 197       }
 198     };
 199     setTransitionEndSupport();
 200     return Util;
 201   }($);
 202
 203   /**
 204    * --------------------------------------------------------------------------
 205    * Bootstrap (v4.1.3): alert.js
 206    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 207    * --------------------------------------------------------------------------
 208    */
 209
 210   var Alert = function ($$$1) {
 211     /**
 212      * ------------------------------------------------------------------------
 213      * Constants
 214      * ------------------------------------------------------------------------
 215      */
 216     var NAME = 'alert';
 217     var VERSION = '4.1.3';
 218     var DATA_KEY = 'bs.alert';
 219     var EVENT_KEY = "." + DATA_KEY;
 220     var DATA_API_KEY = '.data-api';
 221     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 222     var Selector = {
 223       DISMISS: '[data-dismiss="alert"]'
 224     };
 225     var Event = {
 226       CLOSE: "close" + EVENT_KEY,
 227       CLOSED: "closed" + EVENT_KEY,
 228       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
 229     };
 230     var ClassName = {
 231       ALERT: 'alert',
 232       FADE: 'fade',
 233       SHOW: 'show'
 234       /**
 235        * ------------------------------------------------------------------------
 236        * Class Definition
 237        * ------------------------------------------------------------------------
 238        */
 239
 240     };
 241
 242     var Alert =
 243     /*#__PURE__*/
 244     function () {
 245       function Alert(element) {
 246         this._element = element;
 247       } // Getters
 248
 249
 250       var _proto = Alert.prototype;
 251
 252       // Public
 253       _proto.close = function close(element) {
 254         var rootElement = this._element;
 255
 256         if (element) {
 257           rootElement = this._getRootElement(element);
 258         }
 259
 260         var customEvent = this._triggerCloseEvent(rootElement);
 261
 262         if (customEvent.isDefaultPrevented()) {
 263           return;
 264         }
 265
 266         this._removeElement(rootElement);
 267       };
 268
 269       _proto.dispose = function dispose() {
 270         $$$1.removeData(this._element, DATA_KEY);
 271         this._element = null;
 272       }; // Private
 273
 274
 275       _proto._getRootElement = function _getRootElement(element) {
 276         var selector = Util.getSelectorFromElement(element);
 277         var parent = false;
 278
 279         if (selector) {
 280           parent = document.querySelector(selector);
 281         }
 282
 283         if (!parent) {
 284           parent = $$$1(element).closest("." + ClassName.ALERT)[0];
 285         }
 286
 287         return parent;
 288       };
 289
 290       _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
 291         var closeEvent = $$$1.Event(Event.CLOSE);
 292         $$$1(element).trigger(closeEvent);
 293         return closeEvent;
 294       };
 295
 296       _proto._removeElement = function _removeElement(element) {
 297         var _this = this;
 298
 299         $$$1(element).removeClass(ClassName.SHOW);
 300
 301         if (!$$$1(element).hasClass(ClassName.FADE)) {
 302           this._destroyElement(element);
 303
 304           return;
 305         }
 306
 307         var transitionDuration = Util.getTransitionDurationFromElement(element);
 308         $$$1(element).one(Util.TRANSITION_END, function (event) {
 309           return _this._destroyElement(element, event);
 310         }).emulateTransitionEnd(transitionDuration);
 311       };
 312
 313       _proto._destroyElement = function _destroyElement(element) {
 314         $$$1(element).detach().trigger(Event.CLOSED).remove();
 315       }; // Static
 316
 317
 318       Alert._jQueryInterface = function _jQueryInterface(config) {
 319         return this.each(function () {
 320           var $element = $$$1(this);
 321           var data = $element.data(DATA_KEY);
 322
 323           if (!data) {
 324             data = new Alert(this);
 325             $element.data(DATA_KEY, data);
 326           }
 327
 328           if (config === 'close') {
 329             data[config](this);
 330           }
 331         });
 332       };
 333
 334       Alert._handleDismiss = function _handleDismiss(alertInstance) {
 335         return function (event) {
 336           if (event) {
 337             event.preventDefault();
 338           }
 339
 340           alertInstance.close(this);
 341         };
 342       };
 343
 344       _createClass(Alert, null, [{
 345         key: "VERSION",
 346         get: function get() {
 347           return VERSION;
 348         }
 349       }]);
 350
 351       return Alert;
 352     }();
 353     /**
 354      * ------------------------------------------------------------------------
 355      * Data Api implementation
 356      * ------------------------------------------------------------------------
 357      */
 358
 359
 360     $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
 361     /**
 362      * ------------------------------------------------------------------------
 363      * jQuery
 364      * ------------------------------------------------------------------------
 365      */
 366
 367     $$$1.fn[NAME] = Alert._jQueryInterface;
 368     $$$1.fn[NAME].Constructor = Alert;
 369
 370     $$$1.fn[NAME].noConflict = function () {
 371       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
 372       return Alert._jQueryInterface;
 373     };
 374
 375     return Alert;
 376   }($);
 377
 378   /**
 379    * --------------------------------------------------------------------------
 380    * Bootstrap (v4.1.3): button.js
 381    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 382    * --------------------------------------------------------------------------
 383    */
 384
 385   var Button = function ($$$1) {
 386     /**
 387      * ------------------------------------------------------------------------
 388      * Constants
 389      * ------------------------------------------------------------------------
 390      */
 391     var NAME = 'button';
 392     var VERSION = '4.1.3';
 393     var DATA_KEY = 'bs.button';
 394     var EVENT_KEY = "." + DATA_KEY;
 395     var DATA_API_KEY = '.data-api';
 396     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 397     var ClassName = {
 398       ACTIVE: 'active',
 399       BUTTON: 'btn',
 400       FOCUS: 'focus'
 401     };
 402     var Selector = {
 403       DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
 404       DATA_TOGGLE: '[data-toggle="buttons"]',
 405       INPUT: 'input',
 406       ACTIVE: '.active',
 407       BUTTON: '.btn'
 408     };
 409     var Event = {
 410       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
 411       FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
 412       /**
 413        * ------------------------------------------------------------------------
 414        * Class Definition
 415        * ------------------------------------------------------------------------
 416        */
 417
 418     };
 419
 420     var Button =
 421     /*#__PURE__*/
 422     function () {
 423       function Button(element) {
 424         this._element = element;
 425       } // Getters
 426
 427
 428       var _proto = Button.prototype;
 429
 430       // Public
 431       _proto.toggle = function toggle() {
 432         var triggerChangeEvent = true;
 433         var addAriaPressed = true;
 434         var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
 435
 436         if (rootElement) {
 437           var input = this._element.querySelector(Selector.INPUT);
 438
 439           if (input) {
 440             if (input.type === 'radio') {
 441               if (input.checked && this._element.classList.contains(ClassName.ACTIVE)) {
 442                 triggerChangeEvent = false;
 443               } else {
 444                 var activeElement = rootElement.querySelector(Selector.ACTIVE);
 445
 446                 if (activeElement) {
 447                   $$$1(activeElement).removeClass(ClassName.ACTIVE);
 448                 }
 449               }
 450             }
 451
 452             if (triggerChangeEvent) {
 453               if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
 454                 return;
 455               }
 456
 457               input.checked = !this._element.classList.contains(ClassName.ACTIVE);
 458               $$$1(input).trigger('change');
 459             }
 460
 461             input.focus();
 462             addAriaPressed = false;
 463           }
 464         }
 465
 466         if (addAriaPressed) {
 467           this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName.ACTIVE));
 468         }
 469
 470         if (triggerChangeEvent) {
 471           $$$1(this._element).toggleClass(ClassName.ACTIVE);
 472         }
 473       };
 474
 475       _proto.dispose = function dispose() {
 476         $$$1.removeData(this._element, DATA_KEY);
 477         this._element = null;
 478       }; // Static
 479
 480
 481       Button._jQueryInterface = function _jQueryInterface(config) {
 482         return this.each(function () {
 483           var data = $$$1(this).data(DATA_KEY);
 484
 485           if (!data) {
 486             data = new Button(this);
 487             $$$1(this).data(DATA_KEY, data);
 488           }
 489
 490           if (config === 'toggle') {
 491             data[config]();
 492           }
 493         });
 494       };
 495
 496       _createClass(Button, null, [{
 497         key: "VERSION",
 498         get: function get() {
 499           return VERSION;
 500         }
 501       }]);
 502
 503       return Button;
 504     }();
 505     /**
 506      * ------------------------------------------------------------------------
 507      * Data Api implementation
 508      * ------------------------------------------------------------------------
 509      */
 510
 511
 512     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
 513       event.preventDefault();
 514       var button = event.target;
 515
 516       if (!$$$1(button).hasClass(ClassName.BUTTON)) {
 517         button = $$$1(button).closest(Selector.BUTTON);
 518       }
 519
 520       Button._jQueryInterface.call($$$1(button), 'toggle');
 521     }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
 522       var button = $$$1(event.target).closest(Selector.BUTTON)[0];
 523       $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
 524     });
 525     /**
 526      * ------------------------------------------------------------------------
 527      * jQuery
 528      * ------------------------------------------------------------------------
 529      */
 530
 531     $$$1.fn[NAME] = Button._jQueryInterface;
 532     $$$1.fn[NAME].Constructor = Button;
 533
 534     $$$1.fn[NAME].noConflict = function () {
 535       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
 536       return Button._jQueryInterface;
 537     };
 538
 539     return Button;
 540   }($);
 541
 542   /**
 543    * --------------------------------------------------------------------------
 544    * Bootstrap (v4.1.3): carousel.js
 545    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 546    * --------------------------------------------------------------------------
 547    */
 548
 549   var Carousel = function ($$$1) {
 550     /**
 551      * ------------------------------------------------------------------------
 552      * Constants
 553      * ------------------------------------------------------------------------
 554      */
 555     var NAME = 'carousel';
 556     var VERSION = '4.1.3';
 557     var DATA_KEY = 'bs.carousel';
 558     var EVENT_KEY = "." + DATA_KEY;
 559     var DATA_API_KEY = '.data-api';
 560     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 561     var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
 562
 563     var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
 564
 565     var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
 566
 567     var Default = {
 568       interval: 5000,
 569       keyboard: true,
 570       slide: false,
 571       pause: 'hover',
 572       wrap: true
 573     };
 574     var DefaultType = {
 575       interval: '(number|boolean)',
 576       keyboard: 'boolean',
 577       slide: '(boolean|string)',
 578       pause: '(string|boolean)',
 579       wrap: 'boolean'
 580     };
 581     var Direction = {
 582       NEXT: 'next',
 583       PREV: 'prev',
 584       LEFT: 'left',
 585       RIGHT: 'right'
 586     };
 587     var Event = {
 588       SLIDE: "slide" + EVENT_KEY,
 589       SLID: "slid" + EVENT_KEY,
 590       KEYDOWN: "keydown" + EVENT_KEY,
 591       MOUSEENTER: "mouseenter" + EVENT_KEY,
 592       MOUSELEAVE: "mouseleave" + EVENT_KEY,
 593       TOUCHEND: "touchend" + EVENT_KEY,
 594       LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
 595       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
 596     };
 597     var ClassName = {
 598       CAROUSEL: 'carousel',
 599       ACTIVE: 'active',
 600       SLIDE: 'slide',
 601       RIGHT: 'carousel-item-right',
 602       LEFT: 'carousel-item-left',
 603       NEXT: 'carousel-item-next',
 604       PREV: 'carousel-item-prev',
 605       ITEM: 'carousel-item'
 606     };
 607     var Selector = {
 608       ACTIVE: '.active',
 609       ACTIVE_ITEM: '.active.carousel-item',
 610       ITEM: '.carousel-item',
 611       NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
 612       INDICATORS: '.carousel-indicators',
 613       DATA_SLIDE: '[data-slide], [data-slide-to]',
 614       DATA_RIDE: '[data-ride="carousel"]'
 615       /**
 616        * ------------------------------------------------------------------------
 617        * Class Definition
 618        * ------------------------------------------------------------------------
 619        */
 620
 621     };
 622
 623     var Carousel =
 624     /*#__PURE__*/
 625     function () {
 626       function Carousel(element, config) {
 627         this._items = null;
 628         this._interval = null;
 629         this._activeElement = null;
 630         this._isPaused = false;
 631         this._isSliding = false;
 632         this.touchTimeout = null;
 633         this._config = this._getConfig(config);
 634         this._element = $$$1(element)[0];
 635         this._indicatorsElement = this._element.querySelector(Selector.INDICATORS);
 636
 637         this._addEventListeners();
 638       } // Getters
 639
 640
 641       var _proto = Carousel.prototype;
 642
 643       // Public
 644       _proto.next = function next() {
 645         if (!this._isSliding) {
 646           this._slide(Direction.NEXT);
 647         }
 648       };
 649
 650       _proto.nextWhenVisible = function nextWhenVisible() {
 651         // Don't call next when the page isn't visible
 652         // or the carousel or its parent isn't visible
 653         if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
 654           this.next();
 655         }
 656       };
 657
 658       _proto.prev = function prev() {
 659         if (!this._isSliding) {
 660           this._slide(Direction.PREV);
 661         }
 662       };
 663
 664       _proto.pause = function pause(event) {
 665         if (!event) {
 666           this._isPaused = true;
 667         }
 668
 669         if (this._element.querySelector(Selector.NEXT_PREV)) {
 670           Util.triggerTransitionEnd(this._element);
 671           this.cycle(true);
 672         }
 673
 674         clearInterval(this._interval);
 675         this._interval = null;
 676       };
 677
 678       _proto.cycle = function cycle(event) {
 679         if (!event) {
 680           this._isPaused = false;
 681         }
 682
 683         if (this._interval) {
 684           clearInterval(this._interval);
 685           this._interval = null;
 686         }
 687
 688         if (this._config.interval && !this._isPaused) {
 689           this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
 690         }
 691       };
 692
 693       _proto.to = function to(index) {
 694         var _this = this;
 695
 696         this._activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
 697
 698         var activeIndex = this._getItemIndex(this._activeElement);
 699
 700         if (index > this._items.length - 1 || index < 0) {
 701           return;
 702         }
 703
 704         if (this._isSliding) {
 705           $$$1(this._element).one(Event.SLID, function () {
 706             return _this.to(index);
 707           });
 708           return;
 709         }
 710
 711         if (activeIndex === index) {
 712           this.pause();
 713           this.cycle();
 714           return;
 715         }
 716
 717         var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
 718
 719         this._slide(direction, this._items[index]);
 720       };
 721
 722       _proto.dispose = function dispose() {
 723         $$$1(this._element).off(EVENT_KEY);
 724         $$$1.removeData(this._element, DATA_KEY);
 725         this._items = null;
 726         this._config = null;
 727         this._element = null;
 728         this._interval = null;
 729         this._isPaused = null;
 730         this._isSliding = null;
 731         this._activeElement = null;
 732         this._indicatorsElement = null;
 733       }; // Private
 734
 735
 736       _proto._getConfig = function _getConfig(config) {
 737         config = _objectSpread({}, Default, config);
 738         Util.typeCheckConfig(NAME, config, DefaultType);
 739         return config;
 740       };
 741
 742       _proto._addEventListeners = function _addEventListeners() {
 743         var _this2 = this;
 744
 745         if (this._config.keyboard) {
 746           $$$1(this._element).on(Event.KEYDOWN, function (event) {
 747             return _this2._keydown(event);
 748           });
 749         }
 750
 751         if (this._config.pause === 'hover') {
 752           $$$1(this._element).on(Event.MOUSEENTER, function (event) {
 753             return _this2.pause(event);
 754           }).on(Event.MOUSELEAVE, function (event) {
 755             return _this2.cycle(event);
 756           });
 757
 758           if ('ontouchstart' in document.documentElement) {
 759             // If it's a touch-enabled device, mouseenter/leave are fired as
 760             // part of the mouse compatibility events on first tap - the carousel
 761             // would stop cycling until user tapped out of it;
 762             // here, we listen for touchend, explicitly pause the carousel
 763             // (as if it's the second time we tap on it, mouseenter compat event
 764             // is NOT fired) and after a timeout (to allow for mouse compatibility
 765             // events to fire) we explicitly restart cycling
 766             $$$1(this._element).on(Event.TOUCHEND, function () {
 767               _this2.pause();
 768
 769               if (_this2.touchTimeout) {
 770                 clearTimeout(_this2.touchTimeout);
 771               }
 772
 773               _this2.touchTimeout = setTimeout(function (event) {
 774                 return _this2.cycle(event);
 775               }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
 776             });
 777           }
 778         }
 779       };
 780
 781       _proto._keydown = function _keydown(event) {
 782         if (/input|textarea/i.test(event.target.tagName)) {
 783           return;
 784         }
 785
 786         switch (event.which) {
 787           case ARROW_LEFT_KEYCODE:
 788             event.preventDefault();
 789             this.prev();
 790             break;
 791
 792           case ARROW_RIGHT_KEYCODE:
 793             event.preventDefault();
 794             this.next();
 795             break;
 796
 797           default:
 798         }
 799       };
 800
 801       _proto._getItemIndex = function _getItemIndex(element) {
 802         this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector.ITEM)) : [];
 803         return this._items.indexOf(element);
 804       };
 805
 806       _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
 807         var isNextDirection = direction === Direction.NEXT;
 808         var isPrevDirection = direction === Direction.PREV;
 809
 810         var activeIndex = this._getItemIndex(activeElement);
 811
 812         var lastItemIndex = this._items.length - 1;
 813         var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
 814
 815         if (isGoingToWrap && !this._config.wrap) {
 816           return activeElement;
 817         }
 818
 819         var delta = direction === Direction.PREV ? -1 : 1;
 820         var itemIndex = (activeIndex + delta) % this._items.length;
 821         return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
 822       };
 823
 824       _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
 825         var targetIndex = this._getItemIndex(relatedTarget);
 826
 827         var fromIndex = this._getItemIndex(this._element.querySelector(Selector.ACTIVE_ITEM));
 828
 829         var slideEvent = $$$1.Event(Event.SLIDE, {
 830           relatedTarget: relatedTarget,
 831           direction: eventDirectionName,
 832           from: fromIndex,
 833           to: targetIndex
 834         });
 835         $$$1(this._element).trigger(slideEvent);
 836         return slideEvent;
 837       };
 838
 839       _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
 840         if (this._indicatorsElement) {
 841           var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector.ACTIVE));
 842           $$$1(indicators).removeClass(ClassName.ACTIVE);
 843
 844           var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
 845
 846           if (nextIndicator) {
 847             $$$1(nextIndicator).addClass(ClassName.ACTIVE);
 848           }
 849         }
 850       };
 851
 852       _proto._slide = function _slide(direction, element) {
 853         var _this3 = this;
 854
 855         var activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
 856
 857         var activeElementIndex = this._getItemIndex(activeElement);
 858
 859         var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
 860
 861         var nextElementIndex = this._getItemIndex(nextElement);
 862
 863         var isCycling = Boolean(this._interval);
 864         var directionalClassName;
 865         var orderClassName;
 866         var eventDirectionName;
 867
 868         if (direction === Direction.NEXT) {
 869           directionalClassName = ClassName.LEFT;
 870           orderClassName = ClassName.NEXT;
 871           eventDirectionName = Direction.LEFT;
 872         } else {
 873           directionalClassName = ClassName.RIGHT;
 874           orderClassName = ClassName.PREV;
 875           eventDirectionName = Direction.RIGHT;
 876         }
 877
 878         if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
 879           this._isSliding = false;
 880           return;
 881         }
 882
 883         var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
 884
 885         if (slideEvent.isDefaultPrevented()) {
 886           return;
 887         }
 888
 889         if (!activeElement || !nextElement) {
 890           // Some weirdness is happening, so we bail
 891           return;
 892         }
 893
 894         this._isSliding = true;
 895
 896         if (isCycling) {
 897           this.pause();
 898         }
 899
 900         this._setActiveIndicatorElement(nextElement);
 901
 902         var slidEvent = $$$1.Event(Event.SLID, {
 903           relatedTarget: nextElement,
 904           direction: eventDirectionName,
 905           from: activeElementIndex,
 906           to: nextElementIndex
 907         });
 908
 909         if ($$$1(this._element).hasClass(ClassName.SLIDE)) {
 910           $$$1(nextElement).addClass(orderClassName);
 911           Util.reflow(nextElement);
 912           $$$1(activeElement).addClass(directionalClassName);
 913           $$$1(nextElement).addClass(directionalClassName);
 914           var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
 915           $$$1(activeElement).one(Util.TRANSITION_END, function () {
 916             $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
 917             $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
 918             _this3._isSliding = false;
 919             setTimeout(function () {
 920               return $$$1(_this3._element).trigger(slidEvent);
 921             }, 0);
 922           }).emulateTransitionEnd(transitionDuration);
 923         } else {
 924           $$$1(activeElement).removeClass(ClassName.ACTIVE);
 925           $$$1(nextElement).addClass(ClassName.ACTIVE);
 926           this._isSliding = false;
 927           $$$1(this._element).trigger(slidEvent);
 928         }
 929
 930         if (isCycling) {
 931           this.cycle();
 932         }
 933       }; // Static
 934
 935
 936       Carousel._jQueryInterface = function _jQueryInterface(config) {
 937         return this.each(function () {
 938           var data = $$$1(this).data(DATA_KEY);
 939
 940           var _config = _objectSpread({}, Default, $$$1(this).data());
 941
 942           if (typeof config === 'object') {
 943             _config = _objectSpread({}, _config, config);
 944           }
 945
 946           var action = typeof config === 'string' ? config : _config.slide;
 947
 948           if (!data) {
 949             data = new Carousel(this, _config);
 950             $$$1(this).data(DATA_KEY, data);
 951           }
 952
 953           if (typeof config === 'number') {
 954             data.to(config);
 955           } else if (typeof action === 'string') {
 956             if (typeof data[action] === 'undefined') {
 957               throw new TypeError("No method named \"" + action + "\"");
 958             }
 959
 960             data[action]();
 961           } else if (_config.interval) {
 962             data.pause();
 963             data.cycle();
 964           }
 965         });
 966       };
 967
 968       Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
 969         var selector = Util.getSelectorFromElement(this);
 970
 971         if (!selector) {
 972           return;
 973         }
 974
 975         var target = $$$1(selector)[0];
 976
 977         if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
 978           return;
 979         }
 980
 981         var config = _objectSpread({}, $$$1(target).data(), $$$1(this).data());
 982
 983         var slideIndex = this.getAttribute('data-slide-to');
 984
 985         if (slideIndex) {
 986           config.interval = false;
 987         }
 988
 989         Carousel._jQueryInterface.call($$$1(target), config);
 990
 991         if (slideIndex) {
 992           $$$1(target).data(DATA_KEY).to(slideIndex);
 993         }
 994
 995         event.preventDefault();
 996       };
 997
 998       _createClass(Carousel, null, [{
 999         key: "VERSION",
1000         get: function get() {
1001           return VERSION;
1002         }
1003       }, {
1004         key: "Default",
1005         get: function get() {
1006           return Default;
1007         }
1008       }]);
1009
1010       return Carousel;
1011     }();
1012     /**
1013      * ------------------------------------------------------------------------
1014      * Data Api implementation
1015      * ------------------------------------------------------------------------
1016      */
1017
1018
1019     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
1020     $$$1(window).on(Event.LOAD_DATA_API, function () {
1021       var carousels = [].slice.call(document.querySelectorAll(Selector.DATA_RIDE));
1022
1023       for (var i = 0, len = carousels.length; i < len; i++) {
1024         var $carousel = $$$1(carousels[i]);
1025
1026         Carousel._jQueryInterface.call($carousel, $carousel.data());
1027       }
1028     });
1029     /**
1030      * ------------------------------------------------------------------------
1031      * jQuery
1032      * ------------------------------------------------------------------------
1033      */
1034
1035     $$$1.fn[NAME] = Carousel._jQueryInterface;
1036     $$$1.fn[NAME].Constructor = Carousel;
1037
1038     $$$1.fn[NAME].noConflict = function () {
1039       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1040       return Carousel._jQueryInterface;
1041     };
1042
1043     return Carousel;
1044   }($);
1045
1046   /**
1047    * --------------------------------------------------------------------------
1048    * Bootstrap (v4.1.3): collapse.js
1049    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1050    * --------------------------------------------------------------------------
1051    */
1052
1053   var Collapse = function ($$$1) {
1054     /**
1055      * ------------------------------------------------------------------------
1056      * Constants
1057      * ------------------------------------------------------------------------
1058      */
1059     var NAME = 'collapse';
1060     var VERSION = '4.1.3';
1061     var DATA_KEY = 'bs.collapse';
1062     var EVENT_KEY = "." + DATA_KEY;
1063     var DATA_API_KEY = '.data-api';
1064     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1065     var Default = {
1066       toggle: true,
1067       parent: ''
1068     };
1069     var DefaultType = {
1070       toggle: 'boolean',
1071       parent: '(string|element)'
1072     };
1073     var Event = {
1074       SHOW: "show" + EVENT_KEY,
1075       SHOWN: "shown" + EVENT_KEY,
1076       HIDE: "hide" + EVENT_KEY,
1077       HIDDEN: "hidden" + EVENT_KEY,
1078       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
1079     };
1080     var ClassName = {
1081       SHOW: 'show',
1082       COLLAPSE: 'collapse',
1083       COLLAPSING: 'collapsing',
1084       COLLAPSED: 'collapsed'
1085     };
1086     var Dimension = {
1087       WIDTH: 'width',
1088       HEIGHT: 'height'
1089     };
1090     var Selector = {
1091       ACTIVES: '.show, .collapsing',
1092       DATA_TOGGLE: '[data-toggle="collapse"]'
1093       /**
1094        * ------------------------------------------------------------------------
1095        * Class Definition
1096        * ------------------------------------------------------------------------
1097        */
1098
1099     };
1100
1101     var Collapse =
1102     /*#__PURE__*/
1103     function () {
1104       function Collapse(element, config) {
1105         this._isTransitioning = false;
1106         this._element = element;
1107         this._config = this._getConfig(config);
1108         this._triggerArray = $$$1.makeArray(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
1109         var toggleList = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE));
1110
1111         for (var i = 0, len = toggleList.length; i < len; i++) {
1112           var elem = toggleList[i];
1113           var selector = Util.getSelectorFromElement(elem);
1114           var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) {
1115             return foundElem === element;
1116           });
1117
1118           if (selector !== null && filterElement.length > 0) {
1119             this._selector = selector;
1120
1121             this._triggerArray.push(elem);
1122           }
1123         }
1124
1125         this._parent = this._config.parent ? this._getParent() : null;
1126
1127         if (!this._config.parent) {
1128           this._addAriaAndCollapsedClass(this._element, this._triggerArray);
1129         }
1130
1131         if (this._config.toggle) {
1132           this.toggle();
1133         }
1134       } // Getters
1135
1136
1137       var _proto = Collapse.prototype;
1138
1139       // Public
1140       _proto.toggle = function toggle() {
1141         if ($$$1(this._element).hasClass(ClassName.SHOW)) {
1142           this.hide();
1143         } else {
1144           this.show();
1145         }
1146       };
1147
1148       _proto.show = function show() {
1149         var _this = this;
1150
1151         if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
1152           return;
1153         }
1154
1155         var actives;
1156         var activesData;
1157
1158         if (this._parent) {
1159           actives = [].slice.call(this._parent.querySelectorAll(Selector.ACTIVES)).filter(function (elem) {
1160             return elem.getAttribute('data-parent') === _this._config.parent;
1161           });
1162
1163           if (actives.length === 0) {
1164             actives = null;
1165           }
1166         }
1167
1168         if (actives) {
1169           activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
1170
1171           if (activesData && activesData._isTransitioning) {
1172             return;
1173           }
1174         }
1175
1176         var startEvent = $$$1.Event(Event.SHOW);
1177         $$$1(this._element).trigger(startEvent);
1178
1179         if (startEvent.isDefaultPrevented()) {
1180           return;
1181         }
1182
1183         if (actives) {
1184           Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
1185
1186           if (!activesData) {
1187             $$$1(actives).data(DATA_KEY, null);
1188           }
1189         }
1190
1191         var dimension = this._getDimension();
1192
1193         $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
1194         this._element.style[dimension] = 0;
1195
1196         if (this._triggerArray.length) {
1197           $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
1198         }
1199
1200         this.setTransitioning(true);
1201
1202         var complete = function complete() {
1203           $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
1204           _this._element.style[dimension] = '';
1205
1206           _this.setTransitioning(false);
1207
1208           $$$1(_this._element).trigger(Event.SHOWN);
1209         };
1210
1211         var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1212         var scrollSize = "scroll" + capitalizedDimension;
1213         var transitionDuration = Util.getTransitionDurationFromElement(this._element);
1214         $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
1215         this._element.style[dimension] = this._element[scrollSize] + "px";
1216       };
1217
1218       _proto.hide = function hide() {
1219         var _this2 = this;
1220
1221         if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
1222           return;
1223         }
1224
1225         var startEvent = $$$1.Event(Event.HIDE);
1226         $$$1(this._element).trigger(startEvent);
1227
1228         if (startEvent.isDefaultPrevented()) {
1229           return;
1230         }
1231
1232         var dimension = this._getDimension();
1233
1234         this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
1235         Util.reflow(this._element);
1236         $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
1237         var triggerArrayLength = this._triggerArray.length;
1238
1239         if (triggerArrayLength > 0) {
1240           for (var i = 0; i < triggerArrayLength; i++) {
1241             var trigger = this._triggerArray[i];
1242             var selector = Util.getSelectorFromElement(trigger);
1243
1244             if (selector !== null) {
1245               var $elem = $$$1([].slice.call(document.querySelectorAll(selector)));
1246
1247               if (!$elem.hasClass(ClassName.SHOW)) {
1248                 $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
1249               }
1250             }
1251           }
1252         }
1253
1254         this.setTransitioning(true);
1255
1256         var complete = function complete() {
1257           _this2.setTransitioning(false);
1258
1259           $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
1260         };
1261
1262         this._element.style[dimension] = '';
1263         var transitionDuration = Util.getTransitionDurationFromElement(this._element);
1264         $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
1265       };
1266
1267       _proto.setTransitioning = function setTransitioning(isTransitioning) {
1268         this._isTransitioning = isTransitioning;
1269       };
1270
1271       _proto.dispose = function dispose() {
1272         $$$1.removeData(this._element, DATA_KEY);
1273         this._config = null;
1274         this._parent = null;
1275         this._element = null;
1276         this._triggerArray = null;
1277         this._isTransitioning = null;
1278       }; // Private
1279
1280
1281       _proto._getConfig = function _getConfig(config) {
1282         config = _objectSpread({}, Default, config);
1283         config.toggle = Boolean(config.toggle); // Coerce string values
1284
1285         Util.typeCheckConfig(NAME, config, DefaultType);
1286         return config;
1287       };
1288
1289       _proto._getDimension = function _getDimension() {
1290         var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
1291         return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
1292       };
1293
1294       _proto._getParent = function _getParent() {
1295         var _this3 = this;
1296
1297         var parent = null;
1298
1299         if (Util.isElement(this._config.parent)) {
1300           parent = this._config.parent; // It's a jQuery object
1301
1302           if (typeof this._config.parent.jquery !== 'undefined') {
1303             parent = this._config.parent[0];
1304           }
1305         } else {
1306           parent = document.querySelector(this._config.parent);
1307         }
1308
1309         var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
1310         var children = [].slice.call(parent.querySelectorAll(selector));
1311         $$$1(children).each(function (i, element) {
1312           _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
1313         });
1314         return parent;
1315       };
1316
1317       _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
1318         if (element) {
1319           var isOpen = $$$1(element).hasClass(ClassName.SHOW);
1320
1321           if (triggerArray.length) {
1322             $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
1323           }
1324         }
1325       }; // Static
1326
1327
1328       Collapse._getTargetFromElement = function _getTargetFromElement(element) {
1329         var selector = Util.getSelectorFromElement(element);
1330         return selector ? document.querySelector(selector) : null;
1331       };
1332
1333       Collapse._jQueryInterface = function _jQueryInterface(config) {
1334         return this.each(function () {
1335           var $this = $$$1(this);
1336           var data = $this.data(DATA_KEY);
1337
1338           var _config = _objectSpread({}, Default, $this.data(), typeof config === 'object' && config ? config : {});
1339
1340           if (!data && _config.toggle && /show|hide/.test(config)) {
1341             _config.toggle = false;
1342           }
1343
1344           if (!data) {
1345             data = new Collapse(this, _config);
1346             $this.data(DATA_KEY, data);
1347           }
1348
1349           if (typeof config === 'string') {
1350             if (typeof data[config] === 'undefined') {
1351               throw new TypeError("No method named \"" + config + "\"");
1352             }
1353
1354             data[config]();
1355           }
1356         });
1357       };
1358
1359       _createClass(Collapse, null, [{
1360         key: "VERSION",
1361         get: function get() {
1362           return VERSION;
1363         }
1364       }, {
1365         key: "Default",
1366         get: function get() {
1367           return Default;
1368         }
1369       }]);
1370
1371       return Collapse;
1372     }();
1373     /**
1374      * ------------------------------------------------------------------------
1375      * Data Api implementation
1376      * ------------------------------------------------------------------------
1377      */
1378
1379
1380     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
1381       // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1382       if (event.currentTarget.tagName === 'A') {
1383         event.preventDefault();
1384       }
1385
1386       var $trigger = $$$1(this);
1387       var selector = Util.getSelectorFromElement(this);
1388       var selectors = [].slice.call(document.querySelectorAll(selector));
1389       $$$1(selectors).each(function () {
1390         var $target = $$$1(this);
1391         var data = $target.data(DATA_KEY);
1392         var config = data ? 'toggle' : $trigger.data();
1393
1394         Collapse._jQueryInterface.call($target, config);
1395       });
1396     });
1397     /**
1398      * ------------------------------------------------------------------------
1399      * jQuery
1400      * ------------------------------------------------------------------------
1401      */
1402
1403     $$$1.fn[NAME] = Collapse._jQueryInterface;
1404     $$$1.fn[NAME].Constructor = Collapse;
1405
1406     $$$1.fn[NAME].noConflict = function () {
1407       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1408       return Collapse._jQueryInterface;
1409     };
1410
1411     return Collapse;
1412   }($);
1413
1414   /**
1415    * --------------------------------------------------------------------------
1416    * Bootstrap (v4.1.3): dropdown.js
1417    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1418    * --------------------------------------------------------------------------
1419    */
1420
1421   var Dropdown = function ($$$1) {
1422     /**
1423      * ------------------------------------------------------------------------
1424      * Constants
1425      * ------------------------------------------------------------------------
1426      */
1427     var NAME = 'dropdown';
1428     var VERSION = '4.1.3';
1429     var DATA_KEY = 'bs.dropdown';
1430     var EVENT_KEY = "." + DATA_KEY;
1431     var DATA_API_KEY = '.data-api';
1432     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1433     var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
1434
1435     var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
1436
1437     var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
1438
1439     var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
1440
1441     var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
1442
1443     var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
1444
1445     var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
1446     var Event = {
1447       HIDE: "hide" + EVENT_KEY,
1448       HIDDEN: "hidden" + EVENT_KEY,
1449       SHOW: "show" + EVENT_KEY,
1450       SHOWN: "shown" + EVENT_KEY,
1451       CLICK: "click" + EVENT_KEY,
1452       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
1453       KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
1454       KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY
1455     };
1456     var ClassName = {
1457       DISABLED: 'disabled',
1458       SHOW: 'show',
1459       DROPUP: 'dropup',
1460       DROPRIGHT: 'dropright',
1461       DROPLEFT: 'dropleft',
1462       MENURIGHT: 'dropdown-menu-right',
1463       MENULEFT: 'dropdown-menu-left',
1464       POSITION_STATIC: 'position-static'
1465     };
1466     var Selector = {
1467       DATA_TOGGLE: '[data-toggle="dropdown"]',
1468       FORM_CHILD: '.dropdown form',
1469       MENU: '.dropdown-menu',
1470       NAVBAR_NAV: '.navbar-nav',
1471       VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
1472     };
1473     var AttachmentMap = {
1474       TOP: 'top-start',
1475       TOPEND: 'top-end',
1476       BOTTOM: 'bottom-start',
1477       BOTTOMEND: 'bottom-end',
1478       RIGHT: 'right-start',
1479       RIGHTEND: 'right-end',
1480       LEFT: 'left-start',
1481       LEFTEND: 'left-end'
1482     };
1483     var Default = {
1484       offset: 0,
1485       flip: true,
1486       boundary: 'scrollParent',
1487       reference: 'toggle',
1488       display: 'dynamic'
1489     };
1490     var DefaultType = {
1491       offset: '(number|string|function)',
1492       flip: 'boolean',
1493       boundary: '(string|element)',
1494       reference: '(string|element)',
1495       display: 'string'
1496       /**
1497        * ------------------------------------------------------------------------
1498        * Class Definition
1499        * ------------------------------------------------------------------------
1500        */
1501
1502     };
1503
1504     var Dropdown =
1505     /*#__PURE__*/
1506     function () {
1507       function Dropdown(element, config) {
1508         this._element = element;
1509         this._popper = null;
1510         this._config = this._getConfig(config);
1511         this._menu = this._getMenuElement();
1512         this._inNavbar = this._detectNavbar();
1513
1514         this._addEventListeners();
1515       } // Getters
1516
1517
1518       var _proto = Dropdown.prototype;
1519
1520       // Public
1521       _proto.toggle = function toggle() {
1522         if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
1523           return;
1524         }
1525
1526         var parent = Dropdown._getParentFromElement(this._element);
1527
1528         var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
1529
1530         Dropdown._clearMenus();
1531
1532         if (isActive) {
1533           return;
1534         }
1535
1536         var relatedTarget = {
1537           relatedTarget: this._element
1538         };
1539         var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
1540         $$$1(parent).trigger(showEvent);
1541
1542         if (showEvent.isDefaultPrevented()) {
1543           return;
1544         } // Disable totally Popper.js for Dropdown in Navbar
1545
1546
1547         if (!this._inNavbar) {
1548           /**
1549            * Check for Popper dependency
1550            * Popper - https://popper.js.org
1551            */
1552           if (typeof Popper === 'undefined') {
1553             throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
1554           }
1555
1556           var referenceElement = this._element;
1557
1558           if (this._config.reference === 'parent') {
1559             referenceElement = parent;
1560           } else if (Util.isElement(this._config.reference)) {
1561             referenceElement = this._config.reference; // Check if it's jQuery element
1562
1563             if (typeof this._config.reference.jquery !== 'undefined') {
1564               referenceElement = this._config.reference[0];
1565             }
1566           } // If boundary is not `scrollParent`, then set position to `static`
1567           // to allow the menu to "escape" the scroll parent's boundaries
1568           // https://github.com/twbs/bootstrap/issues/24251
1569
1570
1571           if (this._config.boundary !== 'scrollParent') {
1572             $$$1(parent).addClass(ClassName.POSITION_STATIC);
1573           }
1574
1575           this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig());
1576         } // If this is a touch-enabled device we add extra
1577         // empty mouseover listeners to the body's immediate children;
1578         // only needed because of broken event delegation on iOS
1579         // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
1580
1581
1582         if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
1583           $$$1(document.body).children().on('mouseover', null, $$$1.noop);
1584         }
1585
1586         this._element.focus();
1587
1588         this._element.setAttribute('aria-expanded', true);
1589
1590         $$$1(this._menu).toggleClass(ClassName.SHOW);
1591         $$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
1592       };
1593
1594       _proto.dispose = function dispose() {
1595         $$$1.removeData(this._element, DATA_KEY);
1596         $$$1(this._element).off(EVENT_KEY);
1597         this._element = null;
1598         this._menu = null;
1599
1600         if (this._popper !== null) {
1601           this._popper.destroy();
1602
1603           this._popper = null;
1604         }
1605       };
1606
1607       _proto.update = function update() {
1608         this._inNavbar = this._detectNavbar();
1609
1610         if (this._popper !== null) {
1611           this._popper.scheduleUpdate();
1612         }
1613       }; // Private
1614
1615
1616       _proto._addEventListeners = function _addEventListeners() {
1617         var _this = this;
1618
1619         $$$1(this._element).on(Event.CLICK, function (event) {
1620           event.preventDefault();
1621           event.stopPropagation();
1622
1623           _this.toggle();
1624         });
1625       };
1626
1627       _proto._getConfig = function _getConfig(config) {
1628         config = _objectSpread({}, this.constructor.Default, $$$1(this._element).data(), config);
1629         Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
1630         return config;
1631       };
1632
1633       _proto._getMenuElement = function _getMenuElement() {
1634         if (!this._menu) {
1635           var parent = Dropdown._getParentFromElement(this._element);
1636
1637           if (parent) {
1638             this._menu = parent.querySelector(Selector.MENU);
1639           }
1640         }
1641
1642         return this._menu;
1643       };
1644
1645       _proto._getPlacement = function _getPlacement() {
1646         var $parentDropdown = $$$1(this._element.parentNode);
1647         var placement = AttachmentMap.BOTTOM; // Handle dropup
1648
1649         if ($parentDropdown.hasClass(ClassName.DROPUP)) {
1650           placement = AttachmentMap.TOP;
1651
1652           if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1653             placement = AttachmentMap.TOPEND;
1654           }
1655         } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
1656           placement = AttachmentMap.RIGHT;
1657         } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
1658           placement = AttachmentMap.LEFT;
1659         } else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1660           placement = AttachmentMap.BOTTOMEND;
1661         }
1662
1663         return placement;
1664       };
1665
1666       _proto._detectNavbar = function _detectNavbar() {
1667         return $$$1(this._element).closest('.navbar').length > 0;
1668       };
1669
1670       _proto._getPopperConfig = function _getPopperConfig() {
1671         var _this2 = this;
1672
1673         var offsetConf = {};
1674
1675         if (typeof this._config.offset === 'function') {
1676           offsetConf.fn = function (data) {
1677             data.offsets = _objectSpread({}, data.offsets, _this2._config.offset(data.offsets) || {});
1678             return data;
1679           };
1680         } else {
1681           offsetConf.offset = this._config.offset;
1682         }
1683
1684         var popperConfig = {
1685           placement: this._getPlacement(),
1686           modifiers: {
1687             offset: offsetConf,
1688             flip: {
1689               enabled: this._config.flip
1690             },
1691             preventOverflow: {
1692               boundariesElement: this._config.boundary
1693             }
1694           } // Disable Popper.js if we have a static display
1695
1696         };
1697
1698         if (this._config.display === 'static') {
1699           popperConfig.modifiers.applyStyle = {
1700             enabled: false
1701           };
1702         }
1703
1704         return popperConfig;
1705       }; // Static
1706
1707
1708       Dropdown._jQueryInterface = function _jQueryInterface(config) {
1709         return this.each(function () {
1710           var data = $$$1(this).data(DATA_KEY);
1711
1712           var _config = typeof config === 'object' ? config : null;
1713
1714           if (!data) {
1715             data = new Dropdown(this, _config);
1716             $$$1(this).data(DATA_KEY, data);
1717           }
1718
1719           if (typeof config === 'string') {
1720             if (typeof data[config] === 'undefined') {
1721               throw new TypeError("No method named \"" + config + "\"");
1722             }
1723
1724             data[config]();
1725           }
1726         });
1727       };
1728
1729       Dropdown._clearMenus = function _clearMenus(event) {
1730         if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
1731           return;
1732         }
1733
1734         var toggles = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE));
1735
1736         for (var i = 0, len = toggles.length; i < len; i++) {
1737           var parent = Dropdown._getParentFromElement(toggles[i]);
1738
1739           var context = $$$1(toggles[i]).data(DATA_KEY);
1740           var relatedTarget = {
1741             relatedTarget: toggles[i]
1742           };
1743
1744           if (event && event.type === 'click') {
1745             relatedTarget.clickEvent = event;
1746           }
1747
1748           if (!context) {
1749             continue;
1750           }
1751
1752           var dropdownMenu = context._menu;
1753
1754           if (!$$$1(parent).hasClass(ClassName.SHOW)) {
1755             continue;
1756           }
1757
1758           if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
1759             continue;
1760           }
1761
1762           var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
1763           $$$1(parent).trigger(hideEvent);
1764
1765           if (hideEvent.isDefaultPrevented()) {
1766             continue;
1767           } // If this is a touch-enabled device we remove the extra
1768           // empty mouseover listeners we added for iOS support
1769
1770
1771           if ('ontouchstart' in document.documentElement) {
1772             $$$1(document.body).children().off('mouseover', null, $$$1.noop);
1773           }
1774
1775           toggles[i].setAttribute('aria-expanded', 'false');
1776           $$$1(dropdownMenu).removeClass(ClassName.SHOW);
1777           $$$1(parent).removeClass(ClassName.SHOW).trigger($$$1.Event(Event.HIDDEN, relatedTarget));
1778         }
1779       };
1780
1781       Dropdown._getParentFromElement = function _getParentFromElement(element) {
1782         var parent;
1783         var selector = Util.getSelectorFromElement(element);
1784
1785         if (selector) {
1786           parent = document.querySelector(selector);
1787         }
1788
1789         return parent || element.parentNode;
1790       }; // eslint-disable-next-line complexity
1791
1792
1793       Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
1794         // If not input/textarea:
1795         //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
1796         // If input/textarea:
1797         //  - If space key => not a dropdown command
1798         //  - If key is other than escape
1799         //    - If key is not up or down => not a dropdown command
1800         //    - If trigger inside the menu => not a dropdown command
1801         if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $$$1(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
1802           return;
1803         }
1804
1805         event.preventDefault();
1806         event.stopPropagation();
1807
1808         if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
1809           return;
1810         }
1811
1812         var parent = Dropdown._getParentFromElement(this);
1813
1814         var isActive = $$$1(parent).hasClass(ClassName.SHOW);
1815
1816         if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
1817           if (event.which === ESCAPE_KEYCODE) {
1818             var toggle = parent.querySelector(Selector.DATA_TOGGLE);
1819             $$$1(toggle).trigger('focus');
1820           }
1821
1822           $$$1(this).trigger('click');
1823           return;
1824         }
1825
1826         var items = [].slice.call(parent.querySelectorAll(Selector.VISIBLE_ITEMS));
1827
1828         if (items.length === 0) {
1829           return;
1830         }
1831
1832         var index = items.indexOf(event.target);
1833
1834         if (event.which === ARROW_UP_KEYCODE && index > 0) {
1835           // Up
1836           index--;
1837         }
1838
1839         if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
1840           // Down
1841           index++;
1842         }
1843
1844         if (index < 0) {
1845           index = 0;
1846         }
1847
1848         items[index].focus();
1849       };
1850
1851       _createClass(Dropdown, null, [{
1852         key: "VERSION",
1853         get: function get() {
1854           return VERSION;
1855         }
1856       }, {
1857         key: "Default",
1858         get: function get() {
1859           return Default;
1860         }
1861       }, {
1862         key: "DefaultType",
1863         get: function get() {
1864           return DefaultType;
1865         }
1866       }]);
1867
1868       return Dropdown;
1869     }();
1870     /**
1871      * ------------------------------------------------------------------------
1872      * Data Api implementation
1873      * ------------------------------------------------------------------------
1874      */
1875
1876
1877     $$$1(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API + " " + Event.KEYUP_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
1878       event.preventDefault();
1879       event.stopPropagation();
1880
1881       Dropdown._jQueryInterface.call($$$1(this), 'toggle');
1882     }).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) {
1883       e.stopPropagation();
1884     });
1885     /**
1886      * ------------------------------------------------------------------------
1887      * jQuery
1888      * ------------------------------------------------------------------------
1889      */
1890
1891     $$$1.fn[NAME] = Dropdown._jQueryInterface;
1892     $$$1.fn[NAME].Constructor = Dropdown;
1893
1894     $$$1.fn[NAME].noConflict = function () {
1895       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1896       return Dropdown._jQueryInterface;
1897     };
1898
1899     return Dropdown;
1900   }($, Popper);
1901
1902   /**
1903    * --------------------------------------------------------------------------
1904    * Bootstrap (v4.1.3): modal.js
1905    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1906    * --------------------------------------------------------------------------
1907    */
1908
1909   var Modal = function ($$$1) {
1910     /**
1911      * ------------------------------------------------------------------------
1912      * Constants
1913      * ------------------------------------------------------------------------
1914      */
1915     var NAME = 'modal';
1916     var VERSION = '4.1.3';
1917     var DATA_KEY = 'bs.modal';
1918     var EVENT_KEY = "." + DATA_KEY;
1919     var DATA_API_KEY = '.data-api';
1920     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1921     var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
1922
1923     var Default = {
1924       backdrop: true,
1925       keyboard: true,
1926       focus: true,
1927       show: true
1928     };
1929     var DefaultType = {
1930       backdrop: '(boolean|string)',
1931       keyboard: 'boolean',
1932       focus: 'boolean',
1933       show: 'boolean'
1934     };
1935     var Event = {
1936       HIDE: "hide" + EVENT_KEY,
1937       HIDDEN: "hidden" + EVENT_KEY,
1938       SHOW: "show" + EVENT_KEY,
1939       SHOWN: "shown" + EVENT_KEY,
1940       FOCUSIN: "focusin" + EVENT_KEY,
1941       RESIZE: "resize" + EVENT_KEY,
1942       CLICK_DISMISS: "click.dismiss" + EVENT_KEY,
1943       KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY,
1944       MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY,
1945       MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY,
1946       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
1947     };
1948     var ClassName = {
1949       SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
1950       BACKDROP: 'modal-backdrop',
1951       OPEN: 'modal-open',
1952       FADE: 'fade',
1953       SHOW: 'show'
1954     };
1955     var Selector = {
1956       DIALOG: '.modal-dialog',
1957       DATA_TOGGLE: '[data-toggle="modal"]',
1958       DATA_DISMISS: '[data-dismiss="modal"]',
1959       FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
1960       STICKY_CONTENT: '.sticky-top'
1961       /**
1962        * ------------------------------------------------------------------------
1963        * Class Definition
1964        * ------------------------------------------------------------------------
1965        */
1966
1967     };
1968
1969     var Modal =
1970     /*#__PURE__*/
1971     function () {
1972       function Modal(element, config) {
1973         this._config = this._getConfig(config);
1974         this._element = element;
1975         this._dialog = element.querySelector(Selector.DIALOG);
1976         this._backdrop = null;
1977         this._isShown = false;
1978         this._isBodyOverflowing = false;
1979         this._ignoreBackdropClick = false;
1980         this._scrollbarWidth = 0;
1981       } // Getters
1982
1983
1984       var _proto = Modal.prototype;
1985
1986       // Public
1987       _proto.toggle = function toggle(relatedTarget) {
1988         return this._isShown ? this.hide() : this.show(relatedTarget);
1989       };
1990
1991       _proto.show = function show(relatedTarget) {
1992         var _this = this;
1993
1994         if (this._isTransitioning || this._isShown) {
1995           return;
1996         }
1997
1998         if ($$$1(this._element).hasClass(ClassName.FADE)) {
1999           this._isTransitioning = true;
2000         }
2001
2002         var showEvent = $$$1.Event(Event.SHOW, {
2003           relatedTarget: relatedTarget
2004         });
2005         $$$1(this._element).trigger(showEvent);
2006
2007         if (this._isShown || showEvent.isDefaultPrevented()) {
2008           return;
2009         }
2010
2011         this._isShown = true;
2012
2013         this._checkScrollbar();
2014
2015         this._setScrollbar();
2016
2017         this._adjustDialog();
2018
2019         $$$1(document.body).addClass(ClassName.OPEN);
2020
2021         this._setEscapeEvent();
2022
2023         this._setResizeEvent();
2024
2025         $$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function (event) {
2026           return _this.hide(event);
2027         });
2028         $$$1(this._dialog).on(Event.MOUSEDOWN_DISMISS, function () {
2029           $$$1(_this._element).one(Event.MOUSEUP_DISMISS, function (event) {
2030             if ($$$1(event.target).is(_this._element)) {
2031               _this._ignoreBackdropClick = true;
2032             }
2033           });
2034         });
2035
2036         this._showBackdrop(function () {
2037           return _this._showElement(relatedTarget);
2038         });
2039       };
2040
2041       _proto.hide = function hide(event) {
2042         var _this2 = this;
2043
2044         if (event) {
2045           event.preventDefault();
2046         }
2047
2048         if (this._isTransitioning || !this._isShown) {
2049           return;
2050         }
2051
2052         var hideEvent = $$$1.Event(Event.HIDE);
2053         $$$1(this._element).trigger(hideEvent);
2054
2055         if (!this._isShown || hideEvent.isDefaultPrevented()) {
2056           return;
2057         }
2058
2059         this._isShown = false;
2060         var transition = $$$1(this._element).hasClass(ClassName.FADE);
2061
2062         if (transition) {
2063           this._isTransitioning = true;
2064         }
2065
2066         this._setEscapeEvent();
2067
2068         this._setResizeEvent();
2069
2070         $$$1(document).off(Event.FOCUSIN);
2071         $$$1(this._element).removeClass(ClassName.SHOW);
2072         $$$1(this._element).off(Event.CLICK_DISMISS);
2073         $$$1(this._dialog).off(Event.MOUSEDOWN_DISMISS);
2074
2075         if (transition) {
2076           var transitionDuration = Util.getTransitionDurationFromElement(this._element);
2077           $$$1(this._element).one(Util.TRANSITION_END, function (event) {
2078             return _this2._hideModal(event);
2079           }).emulateTransitionEnd(transitionDuration);
2080         } else {
2081           this._hideModal();
2082         }
2083       };
2084
2085       _proto.dispose = function dispose() {
2086         $$$1.removeData(this._element, DATA_KEY);
2087         $$$1(window, document, this._element, this._backdrop).off(EVENT_KEY);
2088         this._config = null;
2089         this._element = null;
2090         this._dialog = null;
2091         this._backdrop = null;
2092         this._isShown = null;
2093         this._isBodyOverflowing = null;
2094         this._ignoreBackdropClick = null;
2095         this._scrollbarWidth = null;
2096       };
2097
2098       _proto.handleUpdate = function handleUpdate() {
2099         this._adjustDialog();
2100       }; // Private
2101
2102
2103       _proto._getConfig = function _getConfig(config) {
2104         config = _objectSpread({}, Default, config);
2105         Util.typeCheckConfig(NAME, config, DefaultType);
2106         return config;
2107       };
2108
2109       _proto._showElement = function _showElement(relatedTarget) {
2110         var _this3 = this;
2111
2112         var transition = $$$1(this._element).hasClass(ClassName.FADE);
2113
2114         if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
2115           // Don't move modal's DOM position
2116           document.body.appendChild(this._element);
2117         }
2118
2119         this._element.style.display = 'block';
2120
2121         this._element.removeAttribute('aria-hidden');
2122
2123         this._element.scrollTop = 0;
2124
2125         if (transition) {
2126           Util.reflow(this._element);
2127         }
2128
2129         $$$1(this._element).addClass(ClassName.SHOW);
2130
2131         if (this._config.focus) {
2132           this._enforceFocus();
2133         }
2134
2135         var shownEvent = $$$1.Event(Event.SHOWN, {
2136           relatedTarget: relatedTarget
2137         });
2138
2139         var transitionComplete = function transitionComplete() {
2140           if (_this3._config.focus) {
2141             _this3._element.focus();
2142           }
2143
2144           _this3._isTransitioning = false;
2145           $$$1(_this3._element).trigger(shownEvent);
2146         };
2147
2148         if (transition) {
2149           var transitionDuration = Util.getTransitionDurationFromElement(this._element);
2150           $$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration);
2151         } else {
2152           transitionComplete();
2153         }
2154       };
2155
2156       _proto._enforceFocus = function _enforceFocus() {
2157         var _this4 = this;
2158
2159         $$$1(document).off(Event.FOCUSIN) // Guard against infinite focus loop
2160         .on(Event.FOCUSIN, function (event) {
2161           if (document !== event.target && _this4._element !== event.target && $$$1(_this4._element).has(event.target).length === 0) {
2162             _this4._element.focus();
2163           }
2164         });
2165       };
2166
2167       _proto._setEscapeEvent = function _setEscapeEvent() {
2168         var _this5 = this;
2169
2170         if (this._isShown && this._config.keyboard) {
2171           $$$1(this._element).on(Event.KEYDOWN_DISMISS, function (event) {
2172             if (event.which === ESCAPE_KEYCODE) {
2173               event.preventDefault();
2174
2175               _this5.hide();
2176             }
2177           });
2178         } else if (!this._isShown) {
2179           $$$1(this._element).off(Event.KEYDOWN_DISMISS);
2180         }
2181       };
2182
2183       _proto._setResizeEvent = function _setResizeEvent() {
2184         var _this6 = this;
2185
2186         if (this._isShown) {
2187           $$$1(window).on(Event.RESIZE, function (event) {
2188             return _this6.handleUpdate(event);
2189           });
2190         } else {
2191           $$$1(window).off(Event.RESIZE);
2192         }
2193       };
2194
2195       _proto._hideModal = function _hideModal() {
2196         var _this7 = this;
2197
2198         this._element.style.display = 'none';
2199
2200         this._element.setAttribute('aria-hidden', true);
2201
2202         this._isTransitioning = false;
2203
2204         this._showBackdrop(function () {
2205           $$$1(document.body).removeClass(ClassName.OPEN);
2206
2207           _this7._resetAdjustments();
2208
2209           _this7._resetScrollbar();
2210
2211           $$$1(_this7._element).trigger(Event.HIDDEN);
2212         });
2213       };
2214
2215       _proto._removeBackdrop = function _removeBackdrop() {
2216         if (this._backdrop) {
2217           $$$1(this._backdrop).remove();
2218           this._backdrop = null;
2219         }
2220       };
2221
2222       _proto._showBackdrop = function _showBackdrop(callback) {
2223         var _this8 = this;
2224
2225         var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
2226
2227         if (this._isShown && this._config.backdrop) {
2228           this._backdrop = document.createElement('div');
2229           this._backdrop.className = ClassName.BACKDROP;
2230
2231           if (animate) {
2232             this._backdrop.classList.add(animate);
2233           }
2234
2235           $$$1(this._backdrop).appendTo(document.body);
2236           $$$1(this._element).on(Event.CLICK_DISMISS, function (event) {
2237             if (_this8._ignoreBackdropClick) {
2238               _this8._ignoreBackdropClick = false;
2239               return;
2240             }
2241
2242             if (event.target !== event.currentTarget) {
2243               return;
2244             }
2245
2246             if (_this8._config.backdrop === 'static') {
2247               _this8._element.focus();
2248             } else {
2249               _this8.hide();
2250             }
2251           });
2252
2253           if (animate) {
2254             Util.reflow(this._backdrop);
2255           }
2256
2257           $$$1(this._backdrop).addClass(ClassName.SHOW);
2258
2259           if (!callback) {
2260             return;
2261           }
2262
2263           if (!animate) {
2264             callback();
2265             return;
2266           }
2267
2268           var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
2269           $$$1(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration);
2270         } else if (!this._isShown && this._backdrop) {
2271           $$$1(this._backdrop).removeClass(ClassName.SHOW);
2272
2273           var callbackRemove = function callbackRemove() {
2274             _this8._removeBackdrop();
2275
2276             if (callback) {
2277               callback();
2278             }
2279           };
2280
2281           if ($$$1(this._element).hasClass(ClassName.FADE)) {
2282             var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
2283
2284             $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration);
2285           } else {
2286             callbackRemove();
2287           }
2288         } else if (callback) {
2289           callback();
2290         }
2291       }; // ----------------------------------------------------------------------
2292       // the following methods are used to handle overflowing modals
2293       // todo (fat): these should probably be refactored out of modal.js
2294       // ----------------------------------------------------------------------
2295
2296
2297       _proto._adjustDialog = function _adjustDialog() {
2298         var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2299
2300         if (!this._isBodyOverflowing && isModalOverflowing) {
2301           this._element.style.paddingLeft = this._scrollbarWidth + "px";
2302         }
2303
2304         if (this._isBodyOverflowing && !isModalOverflowing) {
2305           this._element.style.paddingRight = this._scrollbarWidth + "px";
2306         }
2307       };
2308
2309       _proto._resetAdjustments = function _resetAdjustments() {
2310         this._element.style.paddingLeft = '';
2311         this._element.style.paddingRight = '';
2312       };
2313
2314       _proto._checkScrollbar = function _checkScrollbar() {
2315         var rect = document.body.getBoundingClientRect();
2316         this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
2317         this._scrollbarWidth = this._getScrollbarWidth();
2318       };
2319
2320       _proto._setScrollbar = function _setScrollbar() {
2321         var _this9 = this;
2322
2323         if (this._isBodyOverflowing) {
2324           // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
2325           //   while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
2326           var fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT));
2327           var stickyContent = [].slice.call(document.querySelectorAll(Selector.STICKY_CONTENT)); // Adjust fixed content padding
2328
2329           $$$1(fixedContent).each(function (index, element) {
2330             var actualPadding = element.style.paddingRight;
2331             var calculatedPadding = $$$1(element).css('padding-right');
2332             $$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
2333           }); // Adjust sticky content margin
2334
2335           $$$1(stickyContent).each(function (index, element) {
2336             var actualMargin = element.style.marginRight;
2337             var calculatedMargin = $$$1(element).css('margin-right');
2338             $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
2339           }); // Adjust body padding
2340
2341           var actualPadding = document.body.style.paddingRight;
2342           var calculatedPadding = $$$1(document.body).css('padding-right');
2343           $$$1(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
2344         }
2345       };
2346
2347       _proto._resetScrollbar = function _resetScrollbar() {
2348         // Restore fixed content padding
2349         var fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT));
2350         $$$1(fixedContent).each(function (index, element) {
2351           var padding = $$$1(element).data('padding-right');
2352           $$$1(element).removeData('padding-right');
2353           element.style.paddingRight = padding ? padding : '';
2354         }); // Restore sticky content
2355
2356         var elements = [].slice.call(document.querySelectorAll("" + Selector.STICKY_CONTENT));
2357         $$$1(elements).each(function (index, element) {
2358           var margin = $$$1(element).data('margin-right');
2359
2360           if (typeof margin !== 'undefined') {
2361             $$$1(element).css('margin-right', margin).removeData('margin-right');
2362           }
2363         }); // Restore body padding
2364
2365         var padding = $$$1(document.body).data('padding-right');
2366         $$$1(document.body).removeData('padding-right');
2367         document.body.style.paddingRight = padding ? padding : '';
2368       };
2369
2370       _proto._getScrollbarWidth = function _getScrollbarWidth() {
2371         // thx d.walsh
2372         var scrollDiv = document.createElement('div');
2373         scrollDiv.className = ClassName.SCROLLBAR_MEASURER;
2374         document.body.appendChild(scrollDiv);
2375         var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
2376         document.body.removeChild(scrollDiv);
2377         return scrollbarWidth;
2378       }; // Static
2379
2380
2381       Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
2382         return this.each(function () {
2383           var data = $$$1(this).data(DATA_KEY);
2384
2385           var _config = _objectSpread({}, Default, $$$1(this).data(), typeof config === 'object' && config ? config : {});
2386
2387           if (!data) {
2388             data = new Modal(this, _config);
2389             $$$1(this).data(DATA_KEY, data);
2390           }
2391
2392           if (typeof config === 'string') {
2393             if (typeof data[config] === 'undefined') {
2394               throw new TypeError("No method named \"" + config + "\"");
2395             }
2396
2397             data[config](relatedTarget);
2398           } else if (_config.show) {
2399             data.show(relatedTarget);
2400           }
2401         });
2402       };
2403
2404       _createClass(Modal, null, [{
2405         key: "VERSION",
2406         get: function get() {
2407           return VERSION;
2408         }
2409       }, {
2410         key: "Default",
2411         get: function get() {
2412           return Default;
2413         }
2414       }]);
2415
2416       return Modal;
2417     }();
2418     /**
2419      * ------------------------------------------------------------------------
2420      * Data Api implementation
2421      * ------------------------------------------------------------------------
2422      */
2423
2424
2425     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
2426       var _this10 = this;
2427
2428       var target;
2429       var selector = Util.getSelectorFromElement(this);
2430
2431       if (selector) {
2432         target = document.querySelector(selector);
2433       }
2434
2435       var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _objectSpread({}, $$$1(target).data(), $$$1(this).data());
2436
2437       if (this.tagName === 'A' || this.tagName === 'AREA') {
2438         event.preventDefault();
2439       }
2440
2441       var $target = $$$1(target).one(Event.SHOW, function (showEvent) {
2442         if (showEvent.isDefaultPrevented()) {
2443           // Only register focus restorer if modal will actually get shown
2444           return;
2445         }
2446
2447         $target.one(Event.HIDDEN, function () {
2448           if ($$$1(_this10).is(':visible')) {
2449             _this10.focus();
2450           }
2451         });
2452       });
2453
2454       Modal._jQueryInterface.call($$$1(target), config, this);
2455     });
2456     /**
2457      * ------------------------------------------------------------------------
2458      * jQuery
2459      * ------------------------------------------------------------------------
2460      */
2461
2462     $$$1.fn[NAME] = Modal._jQueryInterface;
2463     $$$1.fn[NAME].Constructor = Modal;
2464
2465     $$$1.fn[NAME].noConflict = function () {
2466       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
2467       return Modal._jQueryInterface;
2468     };
2469
2470     return Modal;
2471   }($);
2472
2473   /**
2474    * --------------------------------------------------------------------------
2475    * Bootstrap (v4.1.3): tooltip.js
2476    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2477    * --------------------------------------------------------------------------
2478    */
2479
2480   var Tooltip = function ($$$1) {
2481     /**
2482      * ------------------------------------------------------------------------
2483      * Constants
2484      * ------------------------------------------------------------------------
2485      */
2486     var NAME = 'tooltip';
2487     var VERSION = '4.1.3';
2488     var DATA_KEY = 'bs.tooltip';
2489     var EVENT_KEY = "." + DATA_KEY;
2490     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
2491     var CLASS_PREFIX = 'bs-tooltip';
2492     var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
2493     var DefaultType = {
2494       animation: 'boolean',
2495       template: 'string',
2496       title: '(string|element|function)',
2497       trigger: 'string',
2498       delay: '(number|object)',
2499       html: 'boolean',
2500       selector: '(string|boolean)',
2501       placement: '(string|function)',
2502       offset: '(number|string)',
2503       container: '(string|element|boolean)',
2504       fallbackPlacement: '(string|array)',
2505       boundary: '(string|element)'
2506     };
2507     var AttachmentMap = {
2508       AUTO: 'auto',
2509       TOP: 'top',
2510       RIGHT: 'right',
2511       BOTTOM: 'bottom',
2512       LEFT: 'left'
2513     };
2514     var Default = {
2515       animation: true,
2516       template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
2517       trigger: 'hover focus',
2518       title: '',
2519       delay: 0,
2520       html: false,
2521       selector: false,
2522       placement: 'top',
2523       offset: 0,
2524       container: false,
2525       fallbackPlacement: 'flip',
2526       boundary: 'scrollParent'
2527     };
2528     var HoverState = {
2529       SHOW: 'show',
2530       OUT: 'out'
2531     };
2532     var Event = {
2533       HIDE: "hide" + EVENT_KEY,
2534       HIDDEN: "hidden" + EVENT_KEY,
2535       SHOW: "show" + EVENT_KEY,
2536       SHOWN: "shown" + EVENT_KEY,
2537       INSERTED: "inserted" + EVENT_KEY,
2538       CLICK: "click" + EVENT_KEY,
2539       FOCUSIN: "focusin" + EVENT_KEY,
2540       FOCUSOUT: "focusout" + EVENT_KEY,
2541       MOUSEENTER: "mouseenter" + EVENT_KEY,
2542       MOUSELEAVE: "mouseleave" + EVENT_KEY
2543     };
2544     var ClassName = {
2545       FADE: 'fade',
2546       SHOW: 'show'
2547     };
2548     var Selector = {
2549       TOOLTIP: '.tooltip',
2550       TOOLTIP_INNER: '.tooltip-inner',
2551       ARROW: '.arrow'
2552     };
2553     var Trigger = {
2554       HOVER: 'hover',
2555       FOCUS: 'focus',
2556       CLICK: 'click',
2557       MANUAL: 'manual'
2558       /**
2559        * ------------------------------------------------------------------------
2560        * Class Definition
2561        * ------------------------------------------------------------------------
2562        */
2563
2564     };
2565
2566     var Tooltip =
2567     /*#__PURE__*/
2568     function () {
2569       function Tooltip(element, config) {
2570         /**
2571          * Check for Popper dependency
2572          * Popper - https://popper.js.org
2573          */
2574         if (typeof Popper === 'undefined') {
2575           throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
2576         } // private
2577
2578
2579         this._isEnabled = true;
2580         this._timeout = 0;
2581         this._hoverState = '';
2582         this._activeTrigger = {};
2583         this._popper = null; // Protected
2584
2585         this.element = element;
2586         this.config = this._getConfig(config);
2587         this.tip = null;
2588
2589         this._setListeners();
2590       } // Getters
2591
2592
2593       var _proto = Tooltip.prototype;
2594
2595       // Public
2596       _proto.enable = function enable() {
2597         this._isEnabled = true;
2598       };
2599
2600       _proto.disable = function disable() {
2601         this._isEnabled = false;
2602       };
2603
2604       _proto.toggleEnabled = function toggleEnabled() {
2605         this._isEnabled = !this._isEnabled;
2606       };
2607
2608       _proto.toggle = function toggle(event) {
2609         if (!this._isEnabled) {
2610           return;
2611         }
2612
2613         if (event) {
2614           var dataKey = this.constructor.DATA_KEY;
2615           var context = $$$1(event.currentTarget).data(dataKey);
2616
2617           if (!context) {
2618             context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2619             $$$1(event.currentTarget).data(dataKey, context);
2620           }
2621
2622           context._activeTrigger.click = !context._activeTrigger.click;
2623
2624           if (context._isWithActiveTrigger()) {
2625             context._enter(null, context);
2626           } else {
2627             context._leave(null, context);
2628           }
2629         } else {
2630           if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
2631             this._leave(null, this);
2632
2633             return;
2634           }
2635
2636           this._enter(null, this);
2637         }
2638       };
2639
2640       _proto.dispose = function dispose() {
2641         clearTimeout(this._timeout);
2642         $$$1.removeData(this.element, this.constructor.DATA_KEY);
2643         $$$1(this.element).off(this.constructor.EVENT_KEY);
2644         $$$1(this.element).closest('.modal').off('hide.bs.modal');
2645
2646         if (this.tip) {
2647           $$$1(this.tip).remove();
2648         }
2649
2650         this._isEnabled = null;
2651         this._timeout = null;
2652         this._hoverState = null;
2653         this._activeTrigger = null;
2654
2655         if (this._popper !== null) {
2656           this._popper.destroy();
2657         }
2658
2659         this._popper = null;
2660         this.element = null;
2661         this.config = null;
2662         this.tip = null;
2663       };
2664
2665       _proto.show = function show() {
2666         var _this = this;
2667
2668         if ($$$1(this.element).css('display') === 'none') {
2669           throw new Error('Please use show on visible elements');
2670         }
2671
2672         var showEvent = $$$1.Event(this.constructor.Event.SHOW);
2673
2674         if (this.isWithContent() && this._isEnabled) {
2675           $$$1(this.element).trigger(showEvent);
2676           var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
2677
2678           if (showEvent.isDefaultPrevented() || !isInTheDom) {
2679             return;
2680           }
2681
2682           var tip = this.getTipElement();
2683           var tipId = Util.getUID(this.constructor.NAME);
2684           tip.setAttribute('id', tipId);
2685           this.element.setAttribute('aria-describedby', tipId);
2686           this.setContent();
2687
2688           if (this.config.animation) {
2689             $$$1(tip).addClass(ClassName.FADE);
2690           }
2691
2692           var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
2693
2694           var attachment = this._getAttachment(placement);
2695
2696           this.addAttachmentClass(attachment);
2697           var container = this.config.container === false ? document.body : $$$1(document).find(this.config.container);
2698           $$$1(tip).data(this.constructor.DATA_KEY, this);
2699
2700           if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
2701             $$$1(tip).appendTo(container);
2702           }
2703
2704           $$$1(this.element).trigger(this.constructor.Event.INSERTED);
2705           this._popper = new Popper(this.element, tip, {
2706             placement: attachment,
2707             modifiers: {
2708               offset: {
2709                 offset: this.config.offset
2710               },
2711               flip: {
2712                 behavior: this.config.fallbackPlacement
2713               },
2714               arrow: {
2715                 element: Selector.ARROW
2716               },
2717               preventOverflow: {
2718                 boundariesElement: this.config.boundary
2719               }
2720             },
2721             onCreate: function onCreate(data) {
2722               if (data.originalPlacement !== data.placement) {
2723                 _this._handlePopperPlacementChange(data);
2724               }
2725             },
2726             onUpdate: function onUpdate(data) {
2727               _this._handlePopperPlacementChange(data);
2728             }
2729           });
2730           $$$1(tip).addClass(ClassName.SHOW); // If this is a touch-enabled device we add extra
2731           // empty mouseover listeners to the body's immediate children;
2732           // only needed because of broken event delegation on iOS
2733           // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
2734
2735           if ('ontouchstart' in document.documentElement) {
2736             $$$1(document.body).children().on('mouseover', null, $$$1.noop);
2737           }
2738
2739           var complete = function complete() {
2740             if (_this.config.animation) {
2741               _this._fixTransition();
2742             }
2743
2744             var prevHoverState = _this._hoverState;
2745             _this._hoverState = null;
2746             $$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
2747
2748             if (prevHoverState === HoverState.OUT) {
2749               _this._leave(null, _this);
2750             }
2751           };
2752
2753           if ($$$1(this.tip).hasClass(ClassName.FADE)) {
2754             var transitionDuration = Util.getTransitionDurationFromElement(this.tip);
2755             $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
2756           } else {
2757             complete();
2758           }
2759         }
2760       };
2761
2762       _proto.hide = function hide(callback) {
2763         var _this2 = this;
2764
2765         var tip = this.getTipElement();
2766         var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
2767
2768         var complete = function complete() {
2769           if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
2770             tip.parentNode.removeChild(tip);
2771           }
2772
2773           _this2._cleanTipClass();
2774
2775           _this2.element.removeAttribute('aria-describedby');
2776
2777           $$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
2778
2779           if (_this2._popper !== null) {
2780             _this2._popper.destroy();
2781           }
2782
2783           if (callback) {
2784             callback();
2785           }
2786         };
2787
2788         $$$1(this.element).trigger(hideEvent);
2789
2790         if (hideEvent.isDefaultPrevented()) {
2791           return;
2792         }
2793
2794         $$$1(tip).removeClass(ClassName.SHOW); // If this is a touch-enabled device we remove the extra
2795         // empty mouseover listeners we added for iOS support
2796
2797         if ('ontouchstart' in document.documentElement) {
2798           $$$1(document.body).children().off('mouseover', null, $$$1.noop);
2799         }
2800
2801         this._activeTrigger[Trigger.CLICK] = false;
2802         this._activeTrigger[Trigger.FOCUS] = false;
2803         this._activeTrigger[Trigger.HOVER] = false;
2804
2805         if ($$$1(this.tip).hasClass(ClassName.FADE)) {
2806           var transitionDuration = Util.getTransitionDurationFromElement(tip);
2807           $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
2808         } else {
2809           complete();
2810         }
2811
2812         this._hoverState = '';
2813       };
2814
2815       _proto.update = function update() {
2816         if (this._popper !== null) {
2817           this._popper.scheduleUpdate();
2818         }
2819       }; // Protected
2820
2821
2822       _proto.isWithContent = function isWithContent() {
2823         return Boolean(this.getTitle());
2824       };
2825
2826       _proto.addAttachmentClass = function addAttachmentClass(attachment) {
2827         $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
2828       };
2829
2830       _proto.getTipElement = function getTipElement() {
2831         this.tip = this.tip || $$$1(this.config.template)[0];
2832         return this.tip;
2833       };
2834
2835       _proto.setContent = function setContent() {
2836         var tip = this.getTipElement();
2837         this.setElementContent($$$1(tip.querySelectorAll(Selector.TOOLTIP_INNER)), this.getTitle());
2838         $$$1(tip).removeClass(ClassName.FADE + " " + ClassName.SHOW);
2839       };
2840
2841       _proto.setElementContent = function setElementContent($element, content) {
2842         var html = this.config.html;
2843
2844         if (typeof content === 'object' && (content.nodeType || content.jquery)) {
2845           // Content is a DOM node or a jQuery
2846           if (html) {
2847             if (!$$$1(content).parent().is($element)) {
2848               $element.empty().append(content);
2849             }
2850           } else {
2851             $element.text($$$1(content).text());
2852           }
2853         } else {
2854           $element[html ? 'html' : 'text'](content);
2855         }
2856       };
2857
2858       _proto.getTitle = function getTitle() {
2859         var title = this.element.getAttribute('data-original-title');
2860
2861         if (!title) {
2862           title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
2863         }
2864
2865         return title;
2866       }; // Private
2867
2868
2869       _proto._getAttachment = function _getAttachment(placement) {
2870         return AttachmentMap[placement.toUpperCase()];
2871       };
2872
2873       _proto._setListeners = function _setListeners() {
2874         var _this3 = this;
2875
2876         var triggers = this.config.trigger.split(' ');
2877         triggers.forEach(function (trigger) {
2878           if (trigger === 'click') {
2879             $$$1(_this3.element).on(_this3.constructor.Event.CLICK, _this3.config.selector, function (event) {
2880               return _this3.toggle(event);
2881             });
2882           } else if (trigger !== Trigger.MANUAL) {
2883             var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
2884             var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
2885             $$$1(_this3.element).on(eventIn, _this3.config.selector, function (event) {
2886               return _this3._enter(event);
2887             }).on(eventOut, _this3.config.selector, function (event) {
2888               return _this3._leave(event);
2889             });
2890           }
2891
2892           $$$1(_this3.element).closest('.modal').on('hide.bs.modal', function () {
2893             return _this3.hide();
2894           });
2895         });
2896
2897         if (this.config.selector) {
2898           this.config = _objectSpread({}, this.config, {
2899             trigger: 'manual',
2900             selector: ''
2901           });
2902         } else {
2903           this._fixTitle();
2904         }
2905       };
2906
2907       _proto._fixTitle = function _fixTitle() {
2908         var titleType = typeof this.element.getAttribute('data-original-title');
2909
2910         if (this.element.getAttribute('title') || titleType !== 'string') {
2911           this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
2912           this.element.setAttribute('title', '');
2913         }
2914       };
2915
2916       _proto._enter = function _enter(event, context) {
2917         var dataKey = this.constructor.DATA_KEY;
2918         context = context || $$$1(event.currentTarget).data(dataKey);
2919
2920         if (!context) {
2921           context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2922           $$$1(event.currentTarget).data(dataKey, context);
2923         }
2924
2925         if (event) {
2926           context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
2927         }
2928
2929         if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
2930           context._hoverState = HoverState.SHOW;
2931           return;
2932         }
2933
2934         clearTimeout(context._timeout);
2935         context._hoverState = HoverState.SHOW;
2936
2937         if (!context.config.delay || !context.config.delay.show) {
2938           context.show();
2939           return;
2940         }
2941
2942         context._timeout = setTimeout(function () {
2943           if (context._hoverState === HoverState.SHOW) {
2944             context.show();
2945           }
2946         }, context.config.delay.show);
2947       };
2948
2949       _proto._leave = function _leave(event, context) {
2950         var dataKey = this.constructor.DATA_KEY;
2951         context = context || $$$1(event.currentTarget).data(dataKey);
2952
2953         if (!context) {
2954           context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2955           $$$1(event.currentTarget).data(dataKey, context);
2956         }
2957
2958         if (event) {
2959           context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
2960         }
2961
2962         if (context._isWithActiveTrigger()) {
2963           return;
2964         }
2965
2966         clearTimeout(context._timeout);
2967         context._hoverState = HoverState.OUT;
2968
2969         if (!context.config.delay || !context.config.delay.hide) {
2970           context.hide();
2971           return;
2972         }
2973
2974         context._timeout = setTimeout(function () {
2975           if (context._hoverState === HoverState.OUT) {
2976             context.hide();
2977           }
2978         }, context.config.delay.hide);
2979       };
2980
2981       _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
2982         for (var trigger in this._activeTrigger) {
2983           if (this._activeTrigger[trigger]) {
2984             return true;
2985           }
2986         }
2987
2988         return false;
2989       };
2990
2991       _proto._getConfig = function _getConfig(config) {
2992         config = _objectSpread({}, this.constructor.Default, $$$1(this.element).data(), typeof config === 'object' && config ? config : {});
2993
2994         if (typeof config.delay === 'number') {
2995           config.delay = {
2996             show: config.delay,
2997             hide: config.delay
2998           };
2999         }
3000
3001         if (typeof config.title === 'number') {
3002           config.title = config.title.toString();
3003         }
3004
3005         if (typeof config.content === 'number') {
3006           config.content = config.content.toString();
3007         }
3008
3009         Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
3010         return config;
3011       };
3012
3013       _proto._getDelegateConfig = function _getDelegateConfig() {
3014         var config = {};
3015
3016         if (this.config) {
3017           for (var key in this.config) {
3018             if (this.constructor.Default[key] !== this.config[key]) {
3019               config[key] = this.config[key];
3020             }
3021           }
3022         }
3023
3024         return config;
3025       };
3026
3027       _proto._cleanTipClass = function _cleanTipClass() {
3028         var $tip = $$$1(this.getTipElement());
3029         var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
3030
3031         if (tabClass !== null && tabClass.length) {
3032           $tip.removeClass(tabClass.join(''));
3033         }
3034       };
3035
3036       _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
3037         var popperInstance = popperData.instance;
3038         this.tip = popperInstance.popper;
3039
3040         this._cleanTipClass();
3041
3042         this.addAttachmentClass(this._getAttachment(popperData.placement));
3043       };
3044
3045       _proto._fixTransition = function _fixTransition() {
3046         var tip = this.getTipElement();
3047         var initConfigAnimation = this.config.animation;
3048
3049         if (tip.getAttribute('x-placement') !== null) {
3050           return;
3051         }
3052
3053         $$$1(tip).removeClass(ClassName.FADE);
3054         this.config.animation = false;
3055         this.hide();
3056         this.show();
3057         this.config.animation = initConfigAnimation;
3058       }; // Static
3059
3060
3061       Tooltip._jQueryInterface = function _jQueryInterface(config) {
3062         return this.each(function () {
3063           var data = $$$1(this).data(DATA_KEY);
3064
3065           var _config = typeof config === 'object' && config;
3066
3067           if (!data && /dispose|hide/.test(config)) {
3068             return;
3069           }
3070
3071           if (!data) {
3072             data = new Tooltip(this, _config);
3073             $$$1(this).data(DATA_KEY, data);
3074           }
3075
3076           if (typeof config === 'string') {
3077             if (typeof data[config] === 'undefined') {
3078               throw new TypeError("No method named \"" + config + "\"");
3079             }
3080
3081             data[config]();
3082           }
3083         });
3084       };
3085
3086       _createClass(Tooltip, null, [{
3087         key: "VERSION",
3088         get: function get() {
3089           return VERSION;
3090         }
3091       }, {
3092         key: "Default",
3093         get: function get() {
3094           return Default;
3095         }
3096       }, {
3097         key: "NAME",
3098         get: function get() {
3099           return NAME;
3100         }
3101       }, {
3102         key: "DATA_KEY",
3103         get: function get() {
3104           return DATA_KEY;
3105         }
3106       }, {
3107         key: "Event",
3108         get: function get() {
3109           return Event;
3110         }
3111       }, {
3112         key: "EVENT_KEY",
3113         get: function get() {
3114           return EVENT_KEY;
3115         }
3116       }, {
3117         key: "DefaultType",
3118         get: function get() {
3119           return DefaultType;
3120         }
3121       }]);
3122
3123       return Tooltip;
3124     }();
3125     /**
3126      * ------------------------------------------------------------------------
3127      * jQuery
3128      * ------------------------------------------------------------------------
3129      */
3130
3131
3132     $$$1.fn[NAME] = Tooltip._jQueryInterface;
3133     $$$1.fn[NAME].Constructor = Tooltip;
3134
3135     $$$1.fn[NAME].noConflict = function () {
3136       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3137       return Tooltip._jQueryInterface;
3138     };
3139
3140     return Tooltip;
3141   }($, Popper);
3142
3143   /**
3144    * --------------------------------------------------------------------------
3145    * Bootstrap (v4.1.3): popover.js
3146    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3147    * --------------------------------------------------------------------------
3148    */
3149
3150   var Popover = function ($$$1) {
3151     /**
3152      * ------------------------------------------------------------------------
3153      * Constants
3154      * ------------------------------------------------------------------------
3155      */
3156     var NAME = 'popover';
3157     var VERSION = '4.1.3';
3158     var DATA_KEY = 'bs.popover';
3159     var EVENT_KEY = "." + DATA_KEY;
3160     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
3161     var CLASS_PREFIX = 'bs-popover';
3162     var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
3163
3164     var Default = _objectSpread({}, Tooltip.Default, {
3165       placement: 'right',
3166       trigger: 'click',
3167       content: '',
3168       template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
3169     });
3170
3171     var DefaultType = _objectSpread({}, Tooltip.DefaultType, {
3172       content: '(string|element|function)'
3173     });
3174
3175     var ClassName = {
3176       FADE: 'fade',
3177       SHOW: 'show'
3178     };
3179     var Selector = {
3180       TITLE: '.popover-header',
3181       CONTENT: '.popover-body'
3182     };
3183     var Event = {
3184       HIDE: "hide" + EVENT_KEY,
3185       HIDDEN: "hidden" + EVENT_KEY,
3186       SHOW: "show" + EVENT_KEY,
3187       SHOWN: "shown" + EVENT_KEY,
3188       INSERTED: "inserted" + EVENT_KEY,
3189       CLICK: "click" + EVENT_KEY,
3190       FOCUSIN: "focusin" + EVENT_KEY,
3191       FOCUSOUT: "focusout" + EVENT_KEY,
3192       MOUSEENTER: "mouseenter" + EVENT_KEY,
3193       MOUSELEAVE: "mouseleave" + EVENT_KEY
3194       /**
3195        * ------------------------------------------------------------------------
3196        * Class Definition
3197        * ------------------------------------------------------------------------
3198        */
3199
3200     };
3201
3202     var Popover =
3203     /*#__PURE__*/
3204     function (_Tooltip) {
3205       _inheritsLoose(Popover, _Tooltip);
3206
3207       function Popover() {
3208         return _Tooltip.apply(this, arguments) || this;
3209       }
3210
3211       var _proto = Popover.prototype;
3212
3213       // Overrides
3214       _proto.isWithContent = function isWithContent() {
3215         return this.getTitle() || this._getContent();
3216       };
3217
3218       _proto.addAttachmentClass = function addAttachmentClass(attachment) {
3219         $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
3220       };
3221
3222       _proto.getTipElement = function getTipElement() {
3223         this.tip = this.tip || $$$1(this.config.template)[0];
3224         return this.tip;
3225       };
3226
3227       _proto.setContent = function setContent() {
3228         var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
3229
3230         this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
3231
3232         var content = this._getContent();
3233
3234         if (typeof content === 'function') {
3235           content = content.call(this.element);
3236         }
3237
3238         this.setElementContent($tip.find(Selector.CONTENT), content);
3239         $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
3240       }; // Private
3241
3242
3243       _proto._getContent = function _getContent() {
3244         return this.element.getAttribute('data-content') || this.config.content;
3245       };
3246
3247       _proto._cleanTipClass = function _cleanTipClass() {
3248         var $tip = $$$1(this.getTipElement());
3249         var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
3250
3251         if (tabClass !== null && tabClass.length > 0) {
3252           $tip.removeClass(tabClass.join(''));
3253         }
3254       }; // Static
3255
3256
3257       Popover._jQueryInterface = function _jQueryInterface(config) {
3258         return this.each(function () {
3259           var data = $$$1(this).data(DATA_KEY);
3260
3261           var _config = typeof config === 'object' ? config : null;
3262
3263           if (!data && /destroy|hide/.test(config)) {
3264             return;
3265           }
3266
3267           if (!data) {
3268             data = new Popover(this, _config);
3269             $$$1(this).data(DATA_KEY, data);
3270           }
3271
3272           if (typeof config === 'string') {
3273             if (typeof data[config] === 'undefined') {
3274               throw new TypeError("No method named \"" + config + "\"");
3275             }
3276
3277             data[config]();
3278           }
3279         });
3280       };
3281
3282       _createClass(Popover, null, [{
3283         key: "VERSION",
3284         // Getters
3285         get: function get() {
3286           return VERSION;
3287         }
3288       }, {
3289         key: "Default",
3290         get: function get() {
3291           return Default;
3292         }
3293       }, {
3294         key: "NAME",
3295         get: function get() {
3296           return NAME;
3297         }
3298       }, {
3299         key: "DATA_KEY",
3300         get: function get() {
3301           return DATA_KEY;
3302         }
3303       }, {
3304         key: "Event",
3305         get: function get() {
3306           return Event;
3307         }
3308       }, {
3309         key: "EVENT_KEY",
3310         get: function get() {
3311           return EVENT_KEY;
3312         }
3313       }, {
3314         key: "DefaultType",
3315         get: function get() {
3316           return DefaultType;
3317         }
3318       }]);
3319
3320       return Popover;
3321     }(Tooltip);
3322     /**
3323      * ------------------------------------------------------------------------
3324      * jQuery
3325      * ------------------------------------------------------------------------
3326      */
3327
3328
3329     $$$1.fn[NAME] = Popover._jQueryInterface;
3330     $$$1.fn[NAME].Constructor = Popover;
3331
3332     $$$1.fn[NAME].noConflict = function () {
3333       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3334       return Popover._jQueryInterface;
3335     };
3336
3337     return Popover;
3338   }($);
3339
3340   /**
3341    * --------------------------------------------------------------------------
3342    * Bootstrap (v4.1.3): scrollspy.js
3343    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3344    * --------------------------------------------------------------------------
3345    */
3346
3347   var ScrollSpy = function ($$$1) {
3348     /**
3349      * ------------------------------------------------------------------------
3350      * Constants
3351      * ------------------------------------------------------------------------
3352      */
3353     var NAME = 'scrollspy';
3354     var VERSION = '4.1.3';
3355     var DATA_KEY = 'bs.scrollspy';
3356     var EVENT_KEY = "." + DATA_KEY;
3357     var DATA_API_KEY = '.data-api';
3358     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
3359     var Default = {
3360       offset: 10,
3361       method: 'auto',
3362       target: ''
3363     };
3364     var DefaultType = {
3365       offset: 'number',
3366       method: 'string',
3367       target: '(string|element)'
3368     };
3369     var Event = {
3370       ACTIVATE: "activate" + EVENT_KEY,
3371       SCROLL: "scroll" + EVENT_KEY,
3372       LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
3373     };
3374     var ClassName = {
3375       DROPDOWN_ITEM: 'dropdown-item',
3376       DROPDOWN_MENU: 'dropdown-menu',
3377       ACTIVE: 'active'
3378     };
3379     var Selector = {
3380       DATA_SPY: '[data-spy="scroll"]',
3381       ACTIVE: '.active',
3382       NAV_LIST_GROUP: '.nav, .list-group',
3383       NAV_LINKS: '.nav-link',
3384       NAV_ITEMS: '.nav-item',
3385       LIST_ITEMS: '.list-group-item',
3386       DROPDOWN: '.dropdown',
3387       DROPDOWN_ITEMS: '.dropdown-item',
3388       DROPDOWN_TOGGLE: '.dropdown-toggle'
3389     };
3390     var OffsetMethod = {
3391       OFFSET: 'offset',
3392       POSITION: 'position'
3393       /**
3394        * ------------------------------------------------------------------------
3395        * Class Definition
3396        * ------------------------------------------------------------------------
3397        */
3398
3399     };
3400
3401     var ScrollSpy =
3402     /*#__PURE__*/
3403     function () {
3404       function ScrollSpy(element, config) {
3405         var _this = this;
3406
3407         this._element = element;
3408         this._scrollElement = element.tagName === 'BODY' ? window : element;
3409         this._config = this._getConfig(config);
3410         this._selector = this._config.target + " " + Selector.NAV_LINKS + "," + (this._config.target + " " + Selector.LIST_ITEMS + ",") + (this._config.target + " " + Selector.DROPDOWN_ITEMS);
3411         this._offsets = [];
3412         this._targets = [];
3413         this._activeTarget = null;
3414         this._scrollHeight = 0;
3415         $$$1(this._scrollElement).on(Event.SCROLL, function (event) {
3416           return _this._process(event);
3417         });
3418         this.refresh();
3419
3420         this._process();
3421       } // Getters
3422
3423
3424       var _proto = ScrollSpy.prototype;
3425
3426       // Public
3427       _proto.refresh = function refresh() {
3428         var _this2 = this;
3429
3430         var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
3431         var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
3432         var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
3433         this._offsets = [];
3434         this._targets = [];
3435         this._scrollHeight = this._getScrollHeight();
3436         var targets = [].slice.call(document.querySelectorAll(this._selector));
3437         targets.map(function (element) {
3438           var target;
3439           var targetSelector = Util.getSelectorFromElement(element);
3440
3441           if (targetSelector) {
3442             target = document.querySelector(targetSelector);
3443           }
3444
3445           if (target) {
3446             var targetBCR = target.getBoundingClientRect();
3447
3448             if (targetBCR.width || targetBCR.height) {
3449               // TODO (fat): remove sketch reliance on jQuery position/offset
3450               return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
3451             }
3452           }
3453
3454           return null;
3455         }).filter(function (item) {
3456           return item;
3457         }).sort(function (a, b) {
3458           return a[0] - b[0];
3459         }).forEach(function (item) {
3460           _this2._offsets.push(item[0]);
3461
3462           _this2._targets.push(item[1]);
3463         });
3464       };
3465
3466       _proto.dispose = function dispose() {
3467         $$$1.removeData(this._element, DATA_KEY);
3468         $$$1(this._scrollElement).off(EVENT_KEY);
3469         this._element = null;
3470         this._scrollElement = null;
3471         this._config = null;
3472         this._selector = null;
3473         this._offsets = null;
3474         this._targets = null;
3475         this._activeTarget = null;
3476         this._scrollHeight = null;
3477       }; // Private
3478
3479
3480       _proto._getConfig = function _getConfig(config) {
3481         config = _objectSpread({}, Default, typeof config === 'object' && config ? config : {});
3482
3483         if (typeof config.target !== 'string') {
3484           var id = $$$1(config.target).attr('id');
3485
3486           if (!id) {
3487             id = Util.getUID(NAME);
3488             $$$1(config.target).attr('id', id);
3489           }
3490
3491           config.target = "#" + id;
3492         }
3493
3494         Util.typeCheckConfig(NAME, config, DefaultType);
3495         return config;
3496       };
3497
3498       _proto._getScrollTop = function _getScrollTop() {
3499         return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
3500       };
3501
3502       _proto._getScrollHeight = function _getScrollHeight() {
3503         return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
3504       };
3505
3506       _proto._getOffsetHeight = function _getOffsetHeight() {
3507         return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
3508       };
3509
3510       _proto._process = function _process() {
3511         var scrollTop = this._getScrollTop() + this._config.offset;
3512
3513         var scrollHeight = this._getScrollHeight();
3514
3515         var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
3516
3517         if (this._scrollHeight !== scrollHeight) {
3518           this.refresh();
3519         }
3520
3521         if (scrollTop >= maxScroll) {
3522           var target = this._targets[this._targets.length - 1];
3523
3524           if (this._activeTarget !== target) {
3525             this._activate(target);
3526           }
3527
3528           return;
3529         }
3530
3531         if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
3532           this._activeTarget = null;
3533
3534           this._clear();
3535
3536           return;
3537         }
3538
3539         var offsetLength = this._offsets.length;
3540
3541         for (var i = offsetLength; i--;) {
3542           var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
3543
3544           if (isActiveTarget) {
3545             this._activate(this._targets[i]);
3546           }
3547         }
3548       };
3549
3550       _proto._activate = function _activate(target) {
3551         this._activeTarget = target;
3552
3553         this._clear();
3554
3555         var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style
3556
3557
3558         queries = queries.map(function (selector) {
3559           return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
3560         });
3561         var $link = $$$1([].slice.call(document.querySelectorAll(queries.join(','))));
3562
3563         if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
3564           $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
3565           $link.addClass(ClassName.ACTIVE);
3566         } else {
3567           // Set triggered link as active
3568           $link.addClass(ClassName.ACTIVE); // Set triggered links parents as active
3569           // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
3570
3571           $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_LINKS + ", " + Selector.LIST_ITEMS).addClass(ClassName.ACTIVE); // Handle special case when .nav-link is inside .nav-item
3572
3573           $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE);
3574         }
3575
3576         $$$1(this._scrollElement).trigger(Event.ACTIVATE, {
3577           relatedTarget: target
3578         });
3579       };
3580
3581       _proto._clear = function _clear() {
3582         var nodes = [].slice.call(document.querySelectorAll(this._selector));
3583         $$$1(nodes).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
3584       }; // Static
3585
3586
3587       ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
3588         return this.each(function () {
3589           var data = $$$1(this).data(DATA_KEY);
3590
3591           var _config = typeof config === 'object' && config;
3592
3593           if (!data) {
3594             data = new ScrollSpy(this, _config);
3595             $$$1(this).data(DATA_KEY, data);
3596           }
3597
3598           if (typeof config === 'string') {
3599             if (typeof data[config] === 'undefined') {
3600               throw new TypeError("No method named \"" + config + "\"");
3601             }
3602
3603             data[config]();
3604           }
3605         });
3606       };
3607
3608       _createClass(ScrollSpy, null, [{
3609         key: "VERSION",
3610         get: function get() {
3611           return VERSION;
3612         }
3613       }, {
3614         key: "Default",
3615         get: function get() {
3616           return Default;
3617         }
3618       }]);
3619
3620       return ScrollSpy;
3621     }();
3622     /**
3623      * ------------------------------------------------------------------------
3624      * Data Api implementation
3625      * ------------------------------------------------------------------------
3626      */
3627
3628
3629     $$$1(window).on(Event.LOAD_DATA_API, function () {
3630       var scrollSpys = [].slice.call(document.querySelectorAll(Selector.DATA_SPY));
3631       var scrollSpysLength = scrollSpys.length;
3632
3633       for (var i = scrollSpysLength; i--;) {
3634         var $spy = $$$1(scrollSpys[i]);
3635
3636         ScrollSpy._jQueryInterface.call($spy, $spy.data());
3637       }
3638     });
3639     /**
3640      * ------------------------------------------------------------------------
3641      * jQuery
3642      * ------------------------------------------------------------------------
3643      */
3644
3645     $$$1.fn[NAME] = ScrollSpy._jQueryInterface;
3646     $$$1.fn[NAME].Constructor = ScrollSpy;
3647
3648     $$$1.fn[NAME].noConflict = function () {
3649       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3650       return ScrollSpy._jQueryInterface;
3651     };
3652
3653     return ScrollSpy;
3654   }($);
3655
3656   /**
3657    * --------------------------------------------------------------------------
3658    * Bootstrap (v4.1.3): tab.js
3659    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3660    * --------------------------------------------------------------------------
3661    */
3662
3663   var Tab = function ($$$1) {
3664     /**
3665      * ------------------------------------------------------------------------
3666      * Constants
3667      * ------------------------------------------------------------------------
3668      */
3669     var NAME = 'tab';
3670     var VERSION = '4.1.3';
3671     var DATA_KEY = 'bs.tab';
3672     var EVENT_KEY = "." + DATA_KEY;
3673     var DATA_API_KEY = '.data-api';
3674     var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
3675     var Event = {
3676       HIDE: "hide" + EVENT_KEY,
3677       HIDDEN: "hidden" + EVENT_KEY,
3678       SHOW: "show" + EVENT_KEY,
3679       SHOWN: "shown" + EVENT_KEY,
3680       CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
3681     };
3682     var ClassName = {
3683       DROPDOWN_MENU: 'dropdown-menu',
3684       ACTIVE: 'active',
3685       DISABLED: 'disabled',
3686       FADE: 'fade',
3687       SHOW: 'show'
3688     };
3689     var Selector = {
3690       DROPDOWN: '.dropdown',
3691       NAV_LIST_GROUP: '.nav, .list-group',
3692       ACTIVE: '.active',
3693       ACTIVE_UL: '> li > .active',
3694       DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
3695       DROPDOWN_TOGGLE: '.dropdown-toggle',
3696       DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
3697       /**
3698        * ------------------------------------------------------------------------
3699        * Class Definition
3700        * ------------------------------------------------------------------------
3701        */
3702
3703     };
3704
3705     var Tab =
3706     /*#__PURE__*/
3707     function () {
3708       function Tab(element) {
3709         this._element = element;
3710       } // Getters
3711
3712
3713       var _proto = Tab.prototype;
3714
3715       // Public
3716       _proto.show = function show() {
3717         var _this = this;
3718
3719         if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
3720           return;
3721         }
3722
3723         var target;
3724         var previous;
3725         var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0];
3726         var selector = Util.getSelectorFromElement(this._element);
3727
3728         if (listElement) {
3729           var itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE;
3730           previous = $$$1.makeArray($$$1(listElement).find(itemSelector));
3731           previous = previous[previous.length - 1];
3732         }
3733
3734         var hideEvent = $$$1.Event(Event.HIDE, {
3735           relatedTarget: this._element
3736         });
3737         var showEvent = $$$1.Event(Event.SHOW, {
3738           relatedTarget: previous
3739         });
3740
3741         if (previous) {
3742           $$$1(previous).trigger(hideEvent);
3743         }
3744
3745         $$$1(this._element).trigger(showEvent);
3746
3747         if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
3748           return;
3749         }
3750
3751         if (selector) {
3752           target = document.querySelector(selector);
3753         }
3754
3755         this._activate(this._element, listElement);
3756
3757         var complete = function complete() {
3758           var hiddenEvent = $$$1.Event(Event.HIDDEN, {
3759             relatedTarget: _this._element
3760           });
3761           var shownEvent = $$$1.Event(Event.SHOWN, {
3762             relatedTarget: previous
3763           });
3764           $$$1(previous).trigger(hiddenEvent);
3765           $$$1(_this._element).trigger(shownEvent);
3766         };
3767
3768         if (target) {
3769           this._activate(target, target.parentNode, complete);
3770         } else {
3771           complete();
3772         }
3773       };
3774
3775       _proto.dispose = function dispose() {
3776         $$$1.removeData(this._element, DATA_KEY);
3777         this._element = null;
3778       }; // Private
3779
3780
3781       _proto._activate = function _activate(element, container, callback) {
3782         var _this2 = this;
3783
3784         var activeElements;
3785
3786         if (container.nodeName === 'UL') {
3787           activeElements = $$$1(container).find(Selector.ACTIVE_UL);
3788         } else {
3789           activeElements = $$$1(container).children(Selector.ACTIVE);
3790         }
3791
3792         var active = activeElements[0];
3793         var isTransitioning = callback && active && $$$1(active).hasClass(ClassName.FADE);
3794
3795         var complete = function complete() {
3796           return _this2._transitionComplete(element, active, callback);
3797         };
3798
3799         if (active && isTransitioning) {
3800           var transitionDuration = Util.getTransitionDurationFromElement(active);
3801           $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
3802         } else {
3803           complete();
3804         }
3805       };
3806
3807       _proto._transitionComplete = function _transitionComplete(element, active, callback) {
3808         if (active) {
3809           $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
3810           var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
3811
3812           if (dropdownChild) {
3813             $$$1(dropdownChild).removeClass(ClassName.ACTIVE);
3814           }
3815
3816           if (active.getAttribute('role') === 'tab') {
3817             active.setAttribute('aria-selected', false);
3818           }
3819         }
3820
3821         $$$1(element).addClass(ClassName.ACTIVE);
3822
3823         if (element.getAttribute('role') === 'tab') {
3824           element.setAttribute('aria-selected', true);
3825         }
3826
3827         Util.reflow(element);
3828         $$$1(element).addClass(ClassName.SHOW);
3829
3830         if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
3831           var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0];
3832
3833           if (dropdownElement) {
3834             var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector.DROPDOWN_TOGGLE));
3835             $$$1(dropdownToggleList).addClass(ClassName.ACTIVE);
3836           }
3837
3838           element.setAttribute('aria-expanded', true);
3839         }
3840
3841         if (callback) {
3842           callback();
3843         }
3844       }; // Static
3845
3846
3847       Tab._jQueryInterface = function _jQueryInterface(config) {
3848         return this.each(function () {
3849           var $this = $$$1(this);
3850           var data = $this.data(DATA_KEY);
3851
3852           if (!data) {
3853             data = new Tab(this);
3854             $this.data(DATA_KEY, data);
3855           }
3856
3857           if (typeof config === 'string') {
3858             if (typeof data[config] === 'undefined') {
3859               throw new TypeError("No method named \"" + config + "\"");
3860             }
3861
3862             data[config]();
3863           }
3864         });
3865       };
3866
3867       _createClass(Tab, null, [{
3868         key: "VERSION",
3869         get: function get() {
3870           return VERSION;
3871         }
3872       }]);
3873
3874       return Tab;
3875     }();
3876     /**
3877      * ------------------------------------------------------------------------
3878      * Data Api implementation
3879      * ------------------------------------------------------------------------
3880      */
3881
3882
3883     $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
3884       event.preventDefault();
3885
3886       Tab._jQueryInterface.call($$$1(this), 'show');
3887     });
3888     /**
3889      * ------------------------------------------------------------------------
3890      * jQuery
3891      * ------------------------------------------------------------------------
3892      */
3893
3894     $$$1.fn[NAME] = Tab._jQueryInterface;
3895     $$$1.fn[NAME].Constructor = Tab;
3896
3897     $$$1.fn[NAME].noConflict = function () {
3898       $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3899       return Tab._jQueryInterface;
3900     };
3901
3902     return Tab;
3903   }($);
3904
3905   /**
3906    * --------------------------------------------------------------------------
3907    * Bootstrap (v4.1.3): index.js
3908    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3909    * --------------------------------------------------------------------------
3910    */
3911
3912   (function ($$$1) {
3913     if (typeof $$$1 === 'undefined') {
3914       throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
3915     }
3916
3917     var version = $$$1.fn.jquery.split(' ')[0].split('.');
3918     var minMajor = 1;
3919     var ltMajor = 2;
3920     var minMinor = 9;
3921     var minPatch = 1;
3922     var maxMajor = 4;
3923
3924     if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
3925       throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
3926     }
3927   })($);
3928
3929   exports.Util = Util;
3930   exports.Alert = Alert;
3931   exports.Button = Button;
3932   exports.Carousel = Carousel;
3933   exports.Collapse = Collapse;
3934   exports.Dropdown = Dropdown;
3935   exports.Modal = Modal;
3936   exports.Popover = Popover;
3937   exports.Scrollspy = ScrollSpy;
3938   exports.Tab = Tab;
3939   exports.Tooltip = Tooltip;
3940
3941   Object.defineProperty(exports, '__esModule', { value: true });
3942
3943 })));
3944 //# sourceMappingURL=bootstrap.js.map