bootstrap.js - cscg24-lolpython - CSCG 2024 Challenge 'Can I Haz Lolpython?'

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