Ignore:
Timestamp:
10/16/21 18:10:51 (3 years ago)
Author:
Ema <ema_spirova@…>
Branches:
master
Children:
eed0bf8
Parents:
6a3a178
Message:

adding new components

Location:
trip-planner-front/node_modules/bootstrap/dist/js
Files:
1 added
10 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • trip-planner-front/node_modules/bootstrap/dist/js/bootstrap.js

    r6a3a178 rfa375fe  
    11/*!
    2   * Bootstrap v5.1.3 (https://getbootstrap.com/)
    3   * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
    4   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    5   */
    6 (function (global, factory) {
    7   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core')) :
    8   typeof define === 'function' && define.amd ? define(['@popperjs/core'], factory) :
    9   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory(global.Popper));
    10 })(this, (function (Popper) { 'use strict';
    11 
    12   function _interopNamespace(e) {
    13     if (e && e.__esModule) return e;
    14     const n = Object.create(null);
    15     if (e) {
    16       for (const k in e) {
    17         if (k !== 'default') {
    18           const d = Object.getOwnPropertyDescriptor(e, k);
    19           Object.defineProperty(n, k, d.get ? d : {
    20             enumerable: true,
    21             get: () => e[k]
    22           });
    23         }
    24       }
    25     }
    26     n.default = e;
    27     return Object.freeze(n);
    28   }
    29 
    30   const Popper__namespace = /*#__PURE__*/_interopNamespace(Popper);
    31 
    32   /**
    33    * --------------------------------------------------------------------------
    34    * Bootstrap (v5.1.3): util/index.js
    35    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    36    * --------------------------------------------------------------------------
    37    */
    38   const MAX_UID = 1000000;
    39   const MILLISECONDS_MULTIPLIER = 1000;
    40   const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
    41 
    42   const toType = obj => {
    43     if (obj === null || obj === undefined) {
    44       return `${obj}`;
    45     }
    46 
    47     return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
    48   };
    49   /**
    50    * --------------------------------------------------------------------------
    51    * Public Util Api
    52    * --------------------------------------------------------------------------
    53    */
    54 
    55 
    56   const getUID = prefix => {
    57     do {
    58       prefix += Math.floor(Math.random() * MAX_UID);
    59     } while (document.getElementById(prefix));
    60 
    61     return prefix;
    62   };
    63 
    64   const getSelector = element => {
    65     let selector = element.getAttribute('data-bs-target');
    66 
    67     if (!selector || selector === '#') {
    68       let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
    69       // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
    70       // `document.querySelector` will rightfully complain it is invalid.
    71       // See https://github.com/twbs/bootstrap/issues/32273
    72 
    73       if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {
    74         return null;
    75       } // Just in case some CMS puts out a full URL with the anchor appended
    76 
    77 
    78       if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
    79         hrefAttr = `#${hrefAttr.split('#')[1]}`;
    80       }
    81 
    82       selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
    83     }
    84 
    85     return selector;
    86   };
    87 
    88   const getSelectorFromElement = element => {
    89     const selector = getSelector(element);
    90 
    91     if (selector) {
    92       return document.querySelector(selector) ? selector : null;
    93     }
    94 
    95     return null;
    96   };
    97 
    98   const getElementFromSelector = element => {
    99     const selector = getSelector(element);
    100     return selector ? document.querySelector(selector) : null;
    101   };
    102 
    103   const getTransitionDurationFromElement = element => {
    104     if (!element) {
    105       return 0;
    106     } // Get transition-duration of the element
    107 
    108 
    109     let {
    110       transitionDuration,
    111       transitionDelay
    112     } = window.getComputedStyle(element);
    113     const floatTransitionDuration = Number.parseFloat(transitionDuration);
    114     const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
    115 
    116     if (!floatTransitionDuration && !floatTransitionDelay) {
    117       return 0;
    118     } // If multiple durations are defined, take the first
    119 
    120 
    121     transitionDuration = transitionDuration.split(',')[0];
    122     transitionDelay = transitionDelay.split(',')[0];
    123     return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
    124   };
    125 
    126   const triggerTransitionEnd = element => {
    127     element.dispatchEvent(new Event(TRANSITION_END));
    128   };
    129 
    130   const isElement = obj => {
    131     if (!obj || typeof obj !== 'object') {
    132       return false;
    133     }
    134 
    135     if (typeof obj.jquery !== 'undefined') {
    136       obj = obj[0];
    137     }
    138 
    139     return typeof obj.nodeType !== 'undefined';
    140   };
    141 
    142   const getElement = obj => {
    143     if (isElement(obj)) {
    144       // it's a jQuery object or a node element
    145       return obj.jquery ? obj[0] : obj;
    146     }
    147 
    148     if (typeof obj === 'string' && obj.length > 0) {
    149       return document.querySelector(obj);
    150     }
    151 
    152     return null;
    153   };
    154 
    155   const typeCheckConfig = (componentName, config, configTypes) => {
    156     Object.keys(configTypes).forEach(property => {
    157       const expectedTypes = configTypes[property];
    158       const value = config[property];
    159       const valueType = value && isElement(value) ? 'element' : toType(value);
    160 
    161       if (!new RegExp(expectedTypes).test(valueType)) {
    162         throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
    163       }
    164     });
    165   };
    166 
    167   const isVisible = element => {
    168     if (!isElement(element) || element.getClientRects().length === 0) {
    169       return false;
    170     }
    171 
    172     return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
    173   };
    174 
    175   const isDisabled = element => {
    176     if (!element || element.nodeType !== Node.ELEMENT_NODE) {
    177       return true;
    178     }
    179 
    180     if (element.classList.contains('disabled')) {
    181       return true;
    182     }
    183 
    184     if (typeof element.disabled !== 'undefined') {
    185       return element.disabled;
    186     }
    187 
    188     return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
    189   };
    190 
    191   const findShadowRoot = element => {
    192     if (!document.documentElement.attachShadow) {
    193       return null;
    194     } // Can find the shadow root otherwise it'll return the document
    195 
    196 
    197     if (typeof element.getRootNode === 'function') {
    198       const root = element.getRootNode();
    199       return root instanceof ShadowRoot ? root : null;
    200     }
    201 
    202     if (element instanceof ShadowRoot) {
    203       return element;
    204     } // when we don't find a shadow root
    205 
    206 
    207     if (!element.parentNode) {
    208       return null;
    209     }
    210 
    211     return findShadowRoot(element.parentNode);
    212   };
    213 
    214   const noop = () => {};
    215   /**
    216    * Trick to restart an element's animation
    217    *
    218    * @param {HTMLElement} element
    219    * @return void
    220    *
    221    * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
    222    */
    223 
    224 
    225   const reflow = element => {
    226     // eslint-disable-next-line no-unused-expressions
    227     element.offsetHeight;
    228   };
    229 
    230   const getjQuery = () => {
    231     const {
    232       jQuery
    233     } = window;
    234 
    235     if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
    236       return jQuery;
    237     }
    238 
    239     return null;
    240   };
    241 
    242   const DOMContentLoadedCallbacks = [];
    243 
    244   const onDOMContentLoaded = callback => {
    245     if (document.readyState === 'loading') {
    246       // add listener on the first call when the document is in loading state
    247       if (!DOMContentLoadedCallbacks.length) {
    248         document.addEventListener('DOMContentLoaded', () => {
    249           DOMContentLoadedCallbacks.forEach(callback => callback());
    250         });
    251       }
    252 
    253       DOMContentLoadedCallbacks.push(callback);
     2 * Bootstrap v3.4.1 (https://getbootstrap.com/)
     3 * Copyright 2011-2019 Twitter, Inc.
     4 * Licensed under the MIT license
     5 */
     6
     7if (typeof jQuery === 'undefined') {
     8  throw new Error('Bootstrap\'s JavaScript requires jQuery')
     9}
     10
     11+function ($) {
     12  'use strict';
     13  var version = $.fn.jquery.split(' ')[0].split('.')
     14  if ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1) || (version[0] > 3)) {
     15    throw new Error('Bootstrap\'s JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4')
     16  }
     17}(jQuery);
     18
     19/* ========================================================================
     20 * Bootstrap: transition.js v3.4.1
     21 * https://getbootstrap.com/docs/3.4/javascript/#transitions
     22 * ========================================================================
     23 * Copyright 2011-2019 Twitter, Inc.
     24 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     25 * ======================================================================== */
     26
     27
     28+function ($) {
     29  'use strict';
     30
     31  // CSS TRANSITION SUPPORT (Shoutout: https://modernizr.com/)
     32  // ============================================================
     33
     34  function transitionEnd() {
     35    var el = document.createElement('bootstrap')
     36
     37    var transEndEventNames = {
     38      WebkitTransition : 'webkitTransitionEnd',
     39      MozTransition    : 'transitionend',
     40      OTransition      : 'oTransitionEnd otransitionend',
     41      transition       : 'transitionend'
     42    }
     43
     44    for (var name in transEndEventNames) {
     45      if (el.style[name] !== undefined) {
     46        return { end: transEndEventNames[name] }
     47      }
     48    }
     49
     50    return false // explicit for ie8 (  ._.)
     51  }
     52
     53  // https://blog.alexmaccaw.com/css-transitions
     54  $.fn.emulateTransitionEnd = function (duration) {
     55    var called = false
     56    var $el = this
     57    $(this).one('bsTransitionEnd', function () { called = true })
     58    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
     59    setTimeout(callback, duration)
     60    return this
     61  }
     62
     63  $(function () {
     64    $.support.transition = transitionEnd()
     65
     66    if (!$.support.transition) return
     67
     68    $.event.special.bsTransitionEnd = {
     69      bindType: $.support.transition.end,
     70      delegateType: $.support.transition.end,
     71      handle: function (e) {
     72        if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
     73      }
     74    }
     75  })
     76
     77}(jQuery);
     78
     79/* ========================================================================
     80 * Bootstrap: alert.js v3.4.1
     81 * https://getbootstrap.com/docs/3.4/javascript/#alerts
     82 * ========================================================================
     83 * Copyright 2011-2019 Twitter, Inc.
     84 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     85 * ======================================================================== */
     86
     87
     88+function ($) {
     89  'use strict';
     90
     91  // ALERT CLASS DEFINITION
     92  // ======================
     93
     94  var dismiss = '[data-dismiss="alert"]'
     95  var Alert   = function (el) {
     96    $(el).on('click', dismiss, this.close)
     97  }
     98
     99  Alert.VERSION = '3.4.1'
     100
     101  Alert.TRANSITION_DURATION = 150
     102
     103  Alert.prototype.close = function (e) {
     104    var $this    = $(this)
     105    var selector = $this.attr('data-target')
     106
     107    if (!selector) {
     108      selector = $this.attr('href')
     109      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
     110    }
     111
     112    selector    = selector === '#' ? [] : selector
     113    var $parent = $(document).find(selector)
     114
     115    if (e) e.preventDefault()
     116
     117    if (!$parent.length) {
     118      $parent = $this.closest('.alert')
     119    }
     120
     121    $parent.trigger(e = $.Event('close.bs.alert'))
     122
     123    if (e.isDefaultPrevented()) return
     124
     125    $parent.removeClass('in')
     126
     127    function removeElement() {
     128      // detach from parent, fire event then clean up data
     129      $parent.detach().trigger('closed.bs.alert').remove()
     130    }
     131
     132    $.support.transition && $parent.hasClass('fade') ?
     133      $parent
     134        .one('bsTransitionEnd', removeElement)
     135        .emulateTransitionEnd(Alert.TRANSITION_DURATION) :
     136      removeElement()
     137  }
     138
     139
     140  // ALERT PLUGIN DEFINITION
     141  // =======================
     142
     143  function Plugin(option) {
     144    return this.each(function () {
     145      var $this = $(this)
     146      var data  = $this.data('bs.alert')
     147
     148      if (!data) $this.data('bs.alert', (data = new Alert(this)))
     149      if (typeof option == 'string') data[option].call($this)
     150    })
     151  }
     152
     153  var old = $.fn.alert
     154
     155  $.fn.alert             = Plugin
     156  $.fn.alert.Constructor = Alert
     157
     158
     159  // ALERT NO CONFLICT
     160  // =================
     161
     162  $.fn.alert.noConflict = function () {
     163    $.fn.alert = old
     164    return this
     165  }
     166
     167
     168  // ALERT DATA-API
     169  // ==============
     170
     171  $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
     172
     173}(jQuery);
     174
     175/* ========================================================================
     176 * Bootstrap: button.js v3.4.1
     177 * https://getbootstrap.com/docs/3.4/javascript/#buttons
     178 * ========================================================================
     179 * Copyright 2011-2019 Twitter, Inc.
     180 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     181 * ======================================================================== */
     182
     183
     184+function ($) {
     185  'use strict';
     186
     187  // BUTTON PUBLIC CLASS DEFINITION
     188  // ==============================
     189
     190  var Button = function (element, options) {
     191    this.$element  = $(element)
     192    this.options   = $.extend({}, Button.DEFAULTS, options)
     193    this.isLoading = false
     194  }
     195
     196  Button.VERSION  = '3.4.1'
     197
     198  Button.DEFAULTS = {
     199    loadingText: 'loading...'
     200  }
     201
     202  Button.prototype.setState = function (state) {
     203    var d    = 'disabled'
     204    var $el  = this.$element
     205    var val  = $el.is('input') ? 'val' : 'html'
     206    var data = $el.data()
     207
     208    state += 'Text'
     209
     210    if (data.resetText == null) $el.data('resetText', $el[val]())
     211
     212    // push to event loop to allow forms to submit
     213    setTimeout($.proxy(function () {
     214      $el[val](data[state] == null ? this.options[state] : data[state])
     215
     216      if (state == 'loadingText') {
     217        this.isLoading = true
     218        $el.addClass(d).attr(d, d).prop(d, true)
     219      } else if (this.isLoading) {
     220        this.isLoading = false
     221        $el.removeClass(d).removeAttr(d).prop(d, false)
     222      }
     223    }, this), 0)
     224  }
     225
     226  Button.prototype.toggle = function () {
     227    var changed = true
     228    var $parent = this.$element.closest('[data-toggle="buttons"]')
     229
     230    if ($parent.length) {
     231      var $input = this.$element.find('input')
     232      if ($input.prop('type') == 'radio') {
     233        if ($input.prop('checked')) changed = false
     234        $parent.find('.active').removeClass('active')
     235        this.$element.addClass('active')
     236      } else if ($input.prop('type') == 'checkbox') {
     237        if (($input.prop('checked')) !== this.$element.hasClass('active')) changed = false
     238        this.$element.toggleClass('active')
     239      }
     240      $input.prop('checked', this.$element.hasClass('active'))
     241      if (changed) $input.trigger('change')
    254242    } else {
    255       callback();
    256     }
    257   };
    258 
    259   const isRTL = () => document.documentElement.dir === 'rtl';
    260 
    261   const defineJQueryPlugin = plugin => {
    262     onDOMContentLoaded(() => {
    263       const $ = getjQuery();
    264       /* istanbul ignore if */
    265 
    266       if ($) {
    267         const name = plugin.NAME;
    268         const JQUERY_NO_CONFLICT = $.fn[name];
    269         $.fn[name] = plugin.jQueryInterface;
    270         $.fn[name].Constructor = plugin;
    271 
    272         $.fn[name].noConflict = () => {
    273           $.fn[name] = JQUERY_NO_CONFLICT;
    274           return plugin.jQueryInterface;
    275         };
    276       }
    277     });
    278   };
    279 
    280   const execute = callback => {
    281     if (typeof callback === 'function') {
    282       callback();
    283     }
    284   };
    285 
    286   const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
    287     if (!waitForTransition) {
    288       execute(callback);
    289       return;
    290     }
    291 
    292     const durationPadding = 5;
    293     const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
    294     let called = false;
    295 
    296     const handler = ({
    297       target
    298     }) => {
    299       if (target !== transitionElement) {
    300         return;
    301       }
    302 
    303       called = true;
    304       transitionElement.removeEventListener(TRANSITION_END, handler);
    305       execute(callback);
    306     };
    307 
    308     transitionElement.addEventListener(TRANSITION_END, handler);
    309     setTimeout(() => {
    310       if (!called) {
    311         triggerTransitionEnd(transitionElement);
    312       }
    313     }, emulatedDuration);
    314   };
    315   /**
    316    * Return the previous/next element of a list.
    317    *
    318    * @param {array} list    The list of elements
    319    * @param activeElement   The active element
    320    * @param shouldGetNext   Choose to get next or previous element
    321    * @param isCycleAllowed
    322    * @return {Element|elem} The proper element
    323    */
    324 
    325 
    326   const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
    327     let index = list.indexOf(activeElement); // if the element does not exist in the list return an element depending on the direction and if cycle is allowed
    328 
    329     if (index === -1) {
    330       return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0];
    331     }
    332 
    333     const listLength = list.length;
    334     index += shouldGetNext ? 1 : -1;
    335 
    336     if (isCycleAllowed) {
    337       index = (index + listLength) % listLength;
    338     }
    339 
    340     return list[Math.max(0, Math.min(index, listLength - 1))];
    341   };
    342 
    343   /**
    344    * --------------------------------------------------------------------------
    345    * Bootstrap (v5.1.3): dom/event-handler.js
    346    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    347    * --------------------------------------------------------------------------
    348    */
    349   /**
    350    * ------------------------------------------------------------------------
    351    * Constants
    352    * ------------------------------------------------------------------------
    353    */
    354 
    355   const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
    356   const stripNameRegex = /\..*/;
    357   const stripUidRegex = /::\d+$/;
    358   const eventRegistry = {}; // Events storage
    359 
    360   let uidEvent = 1;
    361   const customEvents = {
    362     mouseenter: 'mouseover',
    363     mouseleave: 'mouseout'
    364   };
    365   const customEventsRegex = /^(mouseenter|mouseleave)/i;
    366   const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
    367   /**
    368    * ------------------------------------------------------------------------
    369    * Private methods
    370    * ------------------------------------------------------------------------
    371    */
    372 
    373   function getUidEvent(element, uid) {
    374     return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
    375   }
    376 
    377   function getEvent(element) {
    378     const uid = getUidEvent(element);
    379     element.uidEvent = uid;
    380     eventRegistry[uid] = eventRegistry[uid] || {};
    381     return eventRegistry[uid];
    382   }
    383 
    384   function bootstrapHandler(element, fn) {
    385     return function handler(event) {
    386       event.delegateTarget = element;
    387 
    388       if (handler.oneOff) {
    389         EventHandler.off(element, event.type, fn);
    390       }
    391 
    392       return fn.apply(element, [event]);
    393     };
    394   }
    395 
    396   function bootstrapDelegationHandler(element, selector, fn) {
    397     return function handler(event) {
    398       const domElements = element.querySelectorAll(selector);
    399 
    400       for (let {
    401         target
    402       } = event; target && target !== this; target = target.parentNode) {
    403         for (let i = domElements.length; i--;) {
    404           if (domElements[i] === target) {
    405             event.delegateTarget = target;
    406 
    407             if (handler.oneOff) {
    408               EventHandler.off(element, event.type, selector, fn);
    409             }
    410 
    411             return fn.apply(target, [event]);
    412           }
    413         }
    414       } // To please ESLint
    415 
    416 
    417       return null;
    418     };
    419   }
    420 
    421   function findHandler(events, handler, delegationSelector = null) {
    422     const uidEventList = Object.keys(events);
    423 
    424     for (let i = 0, len = uidEventList.length; i < len; i++) {
    425       const event = events[uidEventList[i]];
    426 
    427       if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
    428         return event;
    429       }
    430     }
    431 
    432     return null;
    433   }
    434 
    435   function normalizeParams(originalTypeEvent, handler, delegationFn) {
    436     const delegation = typeof handler === 'string';
    437     const originalHandler = delegation ? delegationFn : handler;
    438     let typeEvent = getTypeEvent(originalTypeEvent);
    439     const isNative = nativeEvents.has(typeEvent);
    440 
    441     if (!isNative) {
    442       typeEvent = originalTypeEvent;
    443     }
    444 
    445     return [delegation, originalHandler, typeEvent];
    446   }
    447 
    448   function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
    449     if (typeof originalTypeEvent !== 'string' || !element) {
    450       return;
    451     }
    452 
    453     if (!handler) {
    454       handler = delegationFn;
    455       delegationFn = null;
    456     } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
    457     // this prevents the handler from being dispatched the same way as mouseover or mouseout does
    458 
    459 
    460     if (customEventsRegex.test(originalTypeEvent)) {
    461       const wrapFn = fn => {
    462         return function (event) {
    463           if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
    464             return fn.call(this, event);
    465           }
    466         };
    467       };
    468 
    469       if (delegationFn) {
    470         delegationFn = wrapFn(delegationFn);
    471       } else {
    472         handler = wrapFn(handler);
    473       }
    474     }
    475 
    476     const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
    477     const events = getEvent(element);
    478     const handlers = events[typeEvent] || (events[typeEvent] = {});
    479     const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
    480 
    481     if (previousFn) {
    482       previousFn.oneOff = previousFn.oneOff && oneOff;
    483       return;
    484     }
    485 
    486     const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
    487     const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
    488     fn.delegationSelector = delegation ? handler : null;
    489     fn.originalHandler = originalHandler;
    490     fn.oneOff = oneOff;
    491     fn.uidEvent = uid;
    492     handlers[uid] = fn;
    493     element.addEventListener(typeEvent, fn, delegation);
    494   }
    495 
    496   function removeHandler(element, events, typeEvent, handler, delegationSelector) {
    497     const fn = findHandler(events[typeEvent], handler, delegationSelector);
    498 
    499     if (!fn) {
    500       return;
    501     }
    502 
    503     element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
    504     delete events[typeEvent][fn.uidEvent];
    505   }
    506 
    507   function removeNamespacedHandlers(element, events, typeEvent, namespace) {
    508     const storeElementEvent = events[typeEvent] || {};
    509     Object.keys(storeElementEvent).forEach(handlerKey => {
    510       if (handlerKey.includes(namespace)) {
    511         const event = storeElementEvent[handlerKey];
    512         removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
    513       }
    514     });
    515   }
    516 
    517   function getTypeEvent(event) {
    518     // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
    519     event = event.replace(stripNameRegex, '');
    520     return customEvents[event] || event;
    521   }
    522 
    523   const EventHandler = {
    524     on(element, event, handler, delegationFn) {
    525       addHandler(element, event, handler, delegationFn, false);
    526     },
    527 
    528     one(element, event, handler, delegationFn) {
    529       addHandler(element, event, handler, delegationFn, true);
    530     },
    531 
    532     off(element, originalTypeEvent, handler, delegationFn) {
    533       if (typeof originalTypeEvent !== 'string' || !element) {
    534         return;
    535       }
    536 
    537       const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
    538       const inNamespace = typeEvent !== originalTypeEvent;
    539       const events = getEvent(element);
    540       const isNamespace = originalTypeEvent.startsWith('.');
    541 
    542       if (typeof originalHandler !== 'undefined') {
    543         // Simplest case: handler is passed, remove that listener ONLY.
    544         if (!events || !events[typeEvent]) {
    545           return;
    546         }
    547 
    548         removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
    549         return;
    550       }
    551 
    552       if (isNamespace) {
    553         Object.keys(events).forEach(elementEvent => {
    554           removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
    555         });
    556       }
    557 
    558       const storeElementEvent = events[typeEvent] || {};
    559       Object.keys(storeElementEvent).forEach(keyHandlers => {
    560         const handlerKey = keyHandlers.replace(stripUidRegex, '');
    561 
    562         if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
    563           const event = storeElementEvent[keyHandlers];
    564           removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
    565         }
    566       });
    567     },
    568 
    569     trigger(element, event, args) {
    570       if (typeof event !== 'string' || !element) {
    571         return null;
    572       }
    573 
    574       const $ = getjQuery();
    575       const typeEvent = getTypeEvent(event);
    576       const inNamespace = event !== typeEvent;
    577       const isNative = nativeEvents.has(typeEvent);
    578       let jQueryEvent;
    579       let bubbles = true;
    580       let nativeDispatch = true;
    581       let defaultPrevented = false;
    582       let evt = null;
    583 
    584       if (inNamespace && $) {
    585         jQueryEvent = $.Event(event, args);
    586         $(element).trigger(jQueryEvent);
    587         bubbles = !jQueryEvent.isPropagationStopped();
    588         nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
    589         defaultPrevented = jQueryEvent.isDefaultPrevented();
    590       }
    591 
    592       if (isNative) {
    593         evt = document.createEvent('HTMLEvents');
    594         evt.initEvent(typeEvent, bubbles, true);
    595       } else {
    596         evt = new CustomEvent(event, {
    597           bubbles,
    598           cancelable: true
    599         });
    600       } // merge custom information in our event
    601 
    602 
    603       if (typeof args !== 'undefined') {
    604         Object.keys(args).forEach(key => {
    605           Object.defineProperty(evt, key, {
    606             get() {
    607               return args[key];
    608             }
    609 
    610           });
    611         });
    612       }
    613 
    614       if (defaultPrevented) {
    615         evt.preventDefault();
    616       }
    617 
    618       if (nativeDispatch) {
    619         element.dispatchEvent(evt);
    620       }
    621 
    622       if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
    623         jQueryEvent.preventDefault();
    624       }
    625 
    626       return evt;
    627     }
    628 
    629   };
    630 
    631   /**
    632    * --------------------------------------------------------------------------
    633    * Bootstrap (v5.1.3): dom/data.js
    634    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    635    * --------------------------------------------------------------------------
    636    */
    637 
    638   /**
    639    * ------------------------------------------------------------------------
    640    * Constants
    641    * ------------------------------------------------------------------------
    642    */
    643   const elementMap = new Map();
    644   const Data = {
    645     set(element, key, instance) {
    646       if (!elementMap.has(element)) {
    647         elementMap.set(element, new Map());
    648       }
    649 
    650       const instanceMap = elementMap.get(element); // make it clear we only want one instance per element
    651       // can be removed later when multiple key/instances are fine to be used
    652 
    653       if (!instanceMap.has(key) && instanceMap.size !== 0) {
    654         // eslint-disable-next-line no-console
    655         console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
    656         return;
    657       }
    658 
    659       instanceMap.set(key, instance);
    660     },
    661 
    662     get(element, key) {
    663       if (elementMap.has(element)) {
    664         return elementMap.get(element).get(key) || null;
    665       }
    666 
    667       return null;
    668     },
    669 
    670     remove(element, key) {
    671       if (!elementMap.has(element)) {
    672         return;
    673       }
    674 
    675       const instanceMap = elementMap.get(element);
    676       instanceMap.delete(key); // free up element references if there are no instances left for an element
    677 
    678       if (instanceMap.size === 0) {
    679         elementMap.delete(element);
    680       }
    681     }
    682 
    683   };
    684 
    685   /**
    686    * --------------------------------------------------------------------------
    687    * Bootstrap (v5.1.3): base-component.js
    688    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    689    * --------------------------------------------------------------------------
    690    */
    691   /**
    692    * ------------------------------------------------------------------------
    693    * Constants
    694    * ------------------------------------------------------------------------
    695    */
    696 
    697   const VERSION = '5.1.3';
    698 
    699   class BaseComponent {
    700     constructor(element) {
    701       element = getElement(element);
    702 
    703       if (!element) {
    704         return;
    705       }
    706 
    707       this._element = element;
    708       Data.set(this._element, this.constructor.DATA_KEY, this);
    709     }
    710 
    711     dispose() {
    712       Data.remove(this._element, this.constructor.DATA_KEY);
    713       EventHandler.off(this._element, this.constructor.EVENT_KEY);
    714       Object.getOwnPropertyNames(this).forEach(propertyName => {
    715         this[propertyName] = null;
    716       });
    717     }
    718 
    719     _queueCallback(callback, element, isAnimated = true) {
    720       executeAfterTransition(callback, element, isAnimated);
    721     }
    722     /** Static */
    723 
    724 
    725     static getInstance(element) {
    726       return Data.get(getElement(element), this.DATA_KEY);
    727     }
    728 
    729     static getOrCreateInstance(element, config = {}) {
    730       return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
    731     }
    732 
    733     static get VERSION() {
    734       return VERSION;
    735     }
    736 
    737     static get NAME() {
    738       throw new Error('You have to implement the static method "NAME", for each component!');
    739     }
    740 
    741     static get DATA_KEY() {
    742       return `bs.${this.NAME}`;
    743     }
    744 
    745     static get EVENT_KEY() {
    746       return `.${this.DATA_KEY}`;
    747     }
    748 
    749   }
    750 
    751   /**
    752    * --------------------------------------------------------------------------
    753    * Bootstrap (v5.1.3): util/component-functions.js
    754    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    755    * --------------------------------------------------------------------------
    756    */
    757 
    758   const enableDismissTrigger = (component, method = 'hide') => {
    759     const clickEvent = `click.dismiss${component.EVENT_KEY}`;
    760     const name = component.NAME;
    761     EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
    762       if (['A', 'AREA'].includes(this.tagName)) {
    763         event.preventDefault();
    764       }
    765 
    766       if (isDisabled(this)) {
    767         return;
    768       }
    769 
    770       const target = getElementFromSelector(this) || this.closest(`.${name}`);
    771       const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
    772 
    773       instance[method]();
    774     });
    775   };
    776 
    777   /**
    778    * --------------------------------------------------------------------------
    779    * Bootstrap (v5.1.3): alert.js
    780    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    781    * --------------------------------------------------------------------------
    782    */
    783   /**
    784    * ------------------------------------------------------------------------
    785    * Constants
    786    * ------------------------------------------------------------------------
    787    */
    788 
    789   const NAME$d = 'alert';
    790   const DATA_KEY$c = 'bs.alert';
    791   const EVENT_KEY$c = `.${DATA_KEY$c}`;
    792   const EVENT_CLOSE = `close${EVENT_KEY$c}`;
    793   const EVENT_CLOSED = `closed${EVENT_KEY$c}`;
    794   const CLASS_NAME_FADE$5 = 'fade';
    795   const CLASS_NAME_SHOW$8 = 'show';
    796   /**
    797    * ------------------------------------------------------------------------
    798    * Class Definition
    799    * ------------------------------------------------------------------------
    800    */
    801 
    802   class Alert extends BaseComponent {
    803     // Getters
    804     static get NAME() {
    805       return NAME$d;
    806     } // Public
    807 
    808 
    809     close() {
    810       const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
    811 
    812       if (closeEvent.defaultPrevented) {
    813         return;
    814       }
    815 
    816       this._element.classList.remove(CLASS_NAME_SHOW$8);
    817 
    818       const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
    819 
    820       this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
    821     } // Private
    822 
    823 
    824     _destroyElement() {
    825       this._element.remove();
    826 
    827       EventHandler.trigger(this._element, EVENT_CLOSED);
    828       this.dispose();
    829     } // Static
    830 
    831 
    832     static jQueryInterface(config) {
    833       return this.each(function () {
    834         const data = Alert.getOrCreateInstance(this);
    835 
    836         if (typeof config !== 'string') {
    837           return;
    838         }
    839 
    840         if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
    841           throw new TypeError(`No method named "${config}"`);
    842         }
    843 
    844         data[config](this);
    845       });
    846     }
    847 
    848   }
    849   /**
    850    * ------------------------------------------------------------------------
    851    * Data Api implementation
    852    * ------------------------------------------------------------------------
    853    */
    854 
    855 
    856   enableDismissTrigger(Alert, 'close');
    857   /**
    858    * ------------------------------------------------------------------------
    859    * jQuery
    860    * ------------------------------------------------------------------------
    861    * add .Alert to jQuery only if jQuery is present
    862    */
    863 
    864   defineJQueryPlugin(Alert);
    865 
    866   /**
    867    * --------------------------------------------------------------------------
    868    * Bootstrap (v5.1.3): button.js
    869    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    870    * --------------------------------------------------------------------------
    871    */
    872   /**
    873    * ------------------------------------------------------------------------
    874    * Constants
    875    * ------------------------------------------------------------------------
    876    */
    877 
    878   const NAME$c = 'button';
    879   const DATA_KEY$b = 'bs.button';
    880   const EVENT_KEY$b = `.${DATA_KEY$b}`;
    881   const DATA_API_KEY$7 = '.data-api';
    882   const CLASS_NAME_ACTIVE$3 = 'active';
    883   const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
    884   const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$b}${DATA_API_KEY$7}`;
    885   /**
    886    * ------------------------------------------------------------------------
    887    * Class Definition
    888    * ------------------------------------------------------------------------
    889    */
    890 
    891   class Button extends BaseComponent {
    892     // Getters
    893     static get NAME() {
    894       return NAME$c;
    895     } // Public
    896 
    897 
    898     toggle() {
    899       // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
    900       this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
    901     } // Static
    902 
    903 
    904     static jQueryInterface(config) {
    905       return this.each(function () {
    906         const data = Button.getOrCreateInstance(this);
    907 
    908         if (config === 'toggle') {
    909           data[config]();
    910         }
    911       });
    912     }
    913 
    914   }
    915   /**
    916    * ------------------------------------------------------------------------
    917    * Data Api implementation
    918    * ------------------------------------------------------------------------
    919    */
    920 
    921 
    922   EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
    923     event.preventDefault();
    924     const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
    925     const data = Button.getOrCreateInstance(button);
    926     data.toggle();
    927   });
    928   /**
    929    * ------------------------------------------------------------------------
    930    * jQuery
    931    * ------------------------------------------------------------------------
    932    * add .Button to jQuery only if jQuery is present
    933    */
    934 
    935   defineJQueryPlugin(Button);
    936 
    937   /**
    938    * --------------------------------------------------------------------------
    939    * Bootstrap (v5.1.3): dom/manipulator.js
    940    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    941    * --------------------------------------------------------------------------
    942    */
    943   function normalizeData(val) {
    944     if (val === 'true') {
    945       return true;
    946     }
    947 
    948     if (val === 'false') {
    949       return false;
    950     }
    951 
    952     if (val === Number(val).toString()) {
    953       return Number(val);
    954     }
    955 
    956     if (val === '' || val === 'null') {
    957       return null;
    958     }
    959 
    960     return val;
    961   }
    962 
    963   function normalizeDataKey(key) {
    964     return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
    965   }
    966 
    967   const Manipulator = {
    968     setDataAttribute(element, key, value) {
    969       element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
    970     },
    971 
    972     removeDataAttribute(element, key) {
    973       element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
    974     },
    975 
    976     getDataAttributes(element) {
    977       if (!element) {
    978         return {};
    979       }
    980 
    981       const attributes = {};
    982       Object.keys(element.dataset).filter(key => key.startsWith('bs')).forEach(key => {
    983         let pureKey = key.replace(/^bs/, '');
    984         pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
    985         attributes[pureKey] = normalizeData(element.dataset[key]);
    986       });
    987       return attributes;
    988     },
    989 
    990     getDataAttribute(element, key) {
    991       return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
    992     },
    993 
    994     offset(element) {
    995       const rect = element.getBoundingClientRect();
    996       return {
    997         top: rect.top + window.pageYOffset,
    998         left: rect.left + window.pageXOffset
    999       };
    1000     },
    1001 
    1002     position(element) {
    1003       return {
    1004         top: element.offsetTop,
    1005         left: element.offsetLeft
    1006       };
    1007     }
    1008 
    1009   };
    1010 
    1011   /**
    1012    * --------------------------------------------------------------------------
    1013    * Bootstrap (v5.1.3): dom/selector-engine.js
    1014    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    1015    * --------------------------------------------------------------------------
    1016    */
    1017   const NODE_TEXT = 3;
    1018   const SelectorEngine = {
    1019     find(selector, element = document.documentElement) {
    1020       return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
    1021     },
    1022 
    1023     findOne(selector, element = document.documentElement) {
    1024       return Element.prototype.querySelector.call(element, selector);
    1025     },
    1026 
    1027     children(element, selector) {
    1028       return [].concat(...element.children).filter(child => child.matches(selector));
    1029     },
    1030 
    1031     parents(element, selector) {
    1032       const parents = [];
    1033       let ancestor = element.parentNode;
    1034 
    1035       while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
    1036         if (ancestor.matches(selector)) {
    1037           parents.push(ancestor);
    1038         }
    1039 
    1040         ancestor = ancestor.parentNode;
    1041       }
    1042 
    1043       return parents;
    1044     },
    1045 
    1046     prev(element, selector) {
    1047       let previous = element.previousElementSibling;
    1048 
    1049       while (previous) {
    1050         if (previous.matches(selector)) {
    1051           return [previous];
    1052         }
    1053 
    1054         previous = previous.previousElementSibling;
    1055       }
    1056 
    1057       return [];
    1058     },
    1059 
    1060     next(element, selector) {
    1061       let next = element.nextElementSibling;
    1062 
    1063       while (next) {
    1064         if (next.matches(selector)) {
    1065           return [next];
    1066         }
    1067 
    1068         next = next.nextElementSibling;
    1069       }
    1070 
    1071       return [];
    1072     },
    1073 
    1074     focusableChildren(element) {
    1075       const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(', ');
    1076       return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
    1077     }
    1078 
    1079   };
    1080 
    1081   /**
    1082    * --------------------------------------------------------------------------
    1083    * Bootstrap (v5.1.3): carousel.js
    1084    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    1085    * --------------------------------------------------------------------------
    1086    */
    1087   /**
    1088    * ------------------------------------------------------------------------
    1089    * Constants
    1090    * ------------------------------------------------------------------------
    1091    */
    1092 
    1093   const NAME$b = 'carousel';
    1094   const DATA_KEY$a = 'bs.carousel';
    1095   const EVENT_KEY$a = `.${DATA_KEY$a}`;
    1096   const DATA_API_KEY$6 = '.data-api';
    1097   const ARROW_LEFT_KEY = 'ArrowLeft';
    1098   const ARROW_RIGHT_KEY = 'ArrowRight';
    1099   const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
    1100 
    1101   const SWIPE_THRESHOLD = 40;
    1102   const Default$a = {
     243      this.$element.attr('aria-pressed', !this.$element.hasClass('active'))
     244      this.$element.toggleClass('active')
     245    }
     246  }
     247
     248
     249  // BUTTON PLUGIN DEFINITION
     250  // ========================
     251
     252  function Plugin(option) {
     253    return this.each(function () {
     254      var $this   = $(this)
     255      var data    = $this.data('bs.button')
     256      var options = typeof option == 'object' && option
     257
     258      if (!data) $this.data('bs.button', (data = new Button(this, options)))
     259
     260      if (option == 'toggle') data.toggle()
     261      else if (option) data.setState(option)
     262    })
     263  }
     264
     265  var old = $.fn.button
     266
     267  $.fn.button             = Plugin
     268  $.fn.button.Constructor = Button
     269
     270
     271  // BUTTON NO CONFLICT
     272  // ==================
     273
     274  $.fn.button.noConflict = function () {
     275    $.fn.button = old
     276    return this
     277  }
     278
     279
     280  // BUTTON DATA-API
     281  // ===============
     282
     283  $(document)
     284    .on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {
     285      var $btn = $(e.target).closest('.btn')
     286      Plugin.call($btn, 'toggle')
     287      if (!($(e.target).is('input[type="radio"], input[type="checkbox"]'))) {
     288        // Prevent double click on radios, and the double selections (so cancellation) on checkboxes
     289        e.preventDefault()
     290        // The target component still receive the focus
     291        if ($btn.is('input,button')) $btn.trigger('focus')
     292        else $btn.find('input:visible,button:visible').first().trigger('focus')
     293      }
     294    })
     295    .on('focus.bs.button.data-api blur.bs.button.data-api', '[data-toggle^="button"]', function (e) {
     296      $(e.target).closest('.btn').toggleClass('focus', /^focus(in)?$/.test(e.type))
     297    })
     298
     299}(jQuery);
     300
     301/* ========================================================================
     302 * Bootstrap: carousel.js v3.4.1
     303 * https://getbootstrap.com/docs/3.4/javascript/#carousel
     304 * ========================================================================
     305 * Copyright 2011-2019 Twitter, Inc.
     306 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     307 * ======================================================================== */
     308
     309
     310+function ($) {
     311  'use strict';
     312
     313  // CAROUSEL CLASS DEFINITION
     314  // =========================
     315
     316  var Carousel = function (element, options) {
     317    this.$element    = $(element)
     318    this.$indicators = this.$element.find('.carousel-indicators')
     319    this.options     = options
     320    this.paused      = null
     321    this.sliding     = null
     322    this.interval    = null
     323    this.$active     = null
     324    this.$items      = null
     325
     326    this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this))
     327
     328    this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element
     329      .on('mouseenter.bs.carousel', $.proxy(this.pause, this))
     330      .on('mouseleave.bs.carousel', $.proxy(this.cycle, this))
     331  }
     332
     333  Carousel.VERSION  = '3.4.1'
     334
     335  Carousel.TRANSITION_DURATION = 600
     336
     337  Carousel.DEFAULTS = {
    1103338    interval: 5000,
    1104     keyboard: true,
    1105     slide: false,
    1106339    pause: 'hover',
    1107340    wrap: true,
    1108     touch: true
    1109   };
    1110   const DefaultType$a = {
    1111     interval: '(number|boolean)',
    1112     keyboard: 'boolean',
    1113     slide: '(boolean|string)',
    1114     pause: '(string|boolean)',
    1115     wrap: 'boolean',
    1116     touch: 'boolean'
    1117   };
    1118   const ORDER_NEXT = 'next';
    1119   const ORDER_PREV = 'prev';
    1120   const DIRECTION_LEFT = 'left';
    1121   const DIRECTION_RIGHT = 'right';
    1122   const KEY_TO_DIRECTION = {
    1123     [ARROW_LEFT_KEY]: DIRECTION_RIGHT,
    1124     [ARROW_RIGHT_KEY]: DIRECTION_LEFT
    1125   };
    1126   const EVENT_SLIDE = `slide${EVENT_KEY$a}`;
    1127   const EVENT_SLID = `slid${EVENT_KEY$a}`;
    1128   const EVENT_KEYDOWN = `keydown${EVENT_KEY$a}`;
    1129   const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY$a}`;
    1130   const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY$a}`;
    1131   const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$a}`;
    1132   const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$a}`;
    1133   const EVENT_TOUCHEND = `touchend${EVENT_KEY$a}`;
    1134   const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$a}`;
    1135   const EVENT_POINTERUP = `pointerup${EVENT_KEY$a}`;
    1136   const EVENT_DRAG_START = `dragstart${EVENT_KEY$a}`;
    1137   const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$a}${DATA_API_KEY$6}`;
    1138   const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
    1139   const CLASS_NAME_CAROUSEL = 'carousel';
    1140   const CLASS_NAME_ACTIVE$2 = 'active';
    1141   const CLASS_NAME_SLIDE = 'slide';
    1142   const CLASS_NAME_END = 'carousel-item-end';
    1143   const CLASS_NAME_START = 'carousel-item-start';
    1144   const CLASS_NAME_NEXT = 'carousel-item-next';
    1145   const CLASS_NAME_PREV = 'carousel-item-prev';
    1146   const CLASS_NAME_POINTER_EVENT = 'pointer-event';
    1147   const SELECTOR_ACTIVE$1 = '.active';
    1148   const SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
    1149   const SELECTOR_ITEM = '.carousel-item';
    1150   const SELECTOR_ITEM_IMG = '.carousel-item img';
    1151   const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev';
    1152   const SELECTOR_INDICATORS = '.carousel-indicators';
    1153   const SELECTOR_INDICATOR = '[data-bs-target]';
    1154   const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
    1155   const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
    1156   const POINTER_TYPE_TOUCH = 'touch';
    1157   const POINTER_TYPE_PEN = 'pen';
    1158   /**
    1159    * ------------------------------------------------------------------------
    1160    * Class Definition
    1161    * ------------------------------------------------------------------------
    1162    */
    1163 
    1164   class Carousel extends BaseComponent {
    1165     constructor(element, config) {
    1166       super(element);
    1167       this._items = null;
    1168       this._interval = null;
    1169       this._activeElement = null;
    1170       this._isPaused = false;
    1171       this._isSliding = false;
    1172       this.touchTimeout = null;
    1173       this.touchStartX = 0;
    1174       this.touchDeltaX = 0;
    1175       this._config = this._getConfig(config);
    1176       this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
    1177       this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
    1178       this._pointerEvent = Boolean(window.PointerEvent);
    1179 
    1180       this._addEventListeners();
    1181     } // Getters
    1182 
    1183 
    1184     static get Default() {
    1185       return Default$a;
    1186     }
    1187 
    1188     static get NAME() {
    1189       return NAME$b;
    1190     } // Public
    1191 
    1192 
    1193     next() {
    1194       this._slide(ORDER_NEXT);
    1195     }
    1196 
    1197     nextWhenVisible() {
    1198       // Don't call next when the page isn't visible
    1199       // or the carousel or its parent isn't visible
    1200       if (!document.hidden && isVisible(this._element)) {
    1201         this.next();
    1202       }
    1203     }
    1204 
    1205     prev() {
    1206       this._slide(ORDER_PREV);
    1207     }
    1208 
    1209     pause(event) {
    1210       if (!event) {
    1211         this._isPaused = true;
    1212       }
    1213 
    1214       if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
    1215         triggerTransitionEnd(this._element);
    1216         this.cycle(true);
    1217       }
    1218 
    1219       clearInterval(this._interval);
    1220       this._interval = null;
    1221     }
    1222 
    1223     cycle(event) {
    1224       if (!event) {
    1225         this._isPaused = false;
    1226       }
    1227 
    1228       if (this._interval) {
    1229         clearInterval(this._interval);
    1230         this._interval = null;
    1231       }
    1232 
    1233       if (this._config && this._config.interval && !this._isPaused) {
    1234         this._updateInterval();
    1235 
    1236         this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
    1237       }
    1238     }
    1239 
    1240     to(index) {
    1241       this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
    1242 
    1243       const activeIndex = this._getItemIndex(this._activeElement);
    1244 
    1245       if (index > this._items.length - 1 || index < 0) {
    1246         return;
    1247       }
    1248 
    1249       if (this._isSliding) {
    1250         EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
    1251         return;
    1252       }
    1253 
    1254       if (activeIndex === index) {
    1255         this.pause();
    1256         this.cycle();
    1257         return;
    1258       }
    1259 
    1260       const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
    1261 
    1262       this._slide(order, this._items[index]);
    1263     } // Private
    1264 
    1265 
    1266     _getConfig(config) {
    1267       config = { ...Default$a,
    1268         ...Manipulator.getDataAttributes(this._element),
    1269         ...(typeof config === 'object' ? config : {})
    1270       };
    1271       typeCheckConfig(NAME$b, config, DefaultType$a);
    1272       return config;
    1273     }
    1274 
    1275     _handleSwipe() {
    1276       const absDeltax = Math.abs(this.touchDeltaX);
    1277 
    1278       if (absDeltax <= SWIPE_THRESHOLD) {
    1279         return;
    1280       }
    1281 
    1282       const direction = absDeltax / this.touchDeltaX;
    1283       this.touchDeltaX = 0;
    1284 
    1285       if (!direction) {
    1286         return;
    1287       }
    1288 
    1289       this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
    1290     }
    1291 
    1292     _addEventListeners() {
    1293       if (this._config.keyboard) {
    1294         EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
    1295       }
    1296 
    1297       if (this._config.pause === 'hover') {
    1298         EventHandler.on(this._element, EVENT_MOUSEENTER, event => this.pause(event));
    1299         EventHandler.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event));
    1300       }
    1301 
    1302       if (this._config.touch && this._touchSupported) {
    1303         this._addTouchEventListeners();
    1304       }
    1305     }
    1306 
    1307     _addTouchEventListeners() {
    1308       const hasPointerPenTouch = event => {
    1309         return this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
    1310       };
    1311 
    1312       const start = event => {
    1313         if (hasPointerPenTouch(event)) {
    1314           this.touchStartX = event.clientX;
    1315         } else if (!this._pointerEvent) {
    1316           this.touchStartX = event.touches[0].clientX;
    1317         }
    1318       };
    1319 
    1320       const move = event => {
    1321         // ensure swiping with one touch and not pinching
    1322         this.touchDeltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX;
    1323       };
    1324 
    1325       const end = event => {
    1326         if (hasPointerPenTouch(event)) {
    1327           this.touchDeltaX = event.clientX - this.touchStartX;
    1328         }
    1329 
    1330         this._handleSwipe();
    1331 
    1332         if (this._config.pause === 'hover') {
    1333           // If it's a touch-enabled device, mouseenter/leave are fired as
    1334           // part of the mouse compatibility events on first tap - the carousel
    1335           // would stop cycling until user tapped out of it;
    1336           // here, we listen for touchend, explicitly pause the carousel
    1337           // (as if it's the second time we tap on it, mouseenter compat event
    1338           // is NOT fired) and after a timeout (to allow for mouse compatibility
    1339           // events to fire) we explicitly restart cycling
    1340           this.pause();
    1341 
    1342           if (this.touchTimeout) {
    1343             clearTimeout(this.touchTimeout);
    1344           }
    1345 
    1346           this.touchTimeout = setTimeout(event => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
    1347         }
    1348       };
    1349 
    1350       SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => {
    1351         EventHandler.on(itemImg, EVENT_DRAG_START, event => event.preventDefault());
    1352       });
    1353 
    1354       if (this._pointerEvent) {
    1355         EventHandler.on(this._element, EVENT_POINTERDOWN, event => start(event));
    1356         EventHandler.on(this._element, EVENT_POINTERUP, event => end(event));
    1357 
    1358         this._element.classList.add(CLASS_NAME_POINTER_EVENT);
    1359       } else {
    1360         EventHandler.on(this._element, EVENT_TOUCHSTART, event => start(event));
    1361         EventHandler.on(this._element, EVENT_TOUCHMOVE, event => move(event));
    1362         EventHandler.on(this._element, EVENT_TOUCHEND, event => end(event));
    1363       }
    1364     }
    1365 
    1366     _keydown(event) {
    1367       if (/input|textarea/i.test(event.target.tagName)) {
    1368         return;
    1369       }
    1370 
    1371       const direction = KEY_TO_DIRECTION[event.key];
    1372 
    1373       if (direction) {
    1374         event.preventDefault();
    1375 
    1376         this._slide(direction);
    1377       }
    1378     }
    1379 
    1380     _getItemIndex(element) {
    1381       this._items = element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
    1382       return this._items.indexOf(element);
    1383     }
    1384 
    1385     _getItemByOrder(order, activeElement) {
    1386       const isNext = order === ORDER_NEXT;
    1387       return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap);
    1388     }
    1389 
    1390     _triggerSlideEvent(relatedTarget, eventDirectionName) {
    1391       const targetIndex = this._getItemIndex(relatedTarget);
    1392 
    1393       const fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element));
    1394 
    1395       return EventHandler.trigger(this._element, EVENT_SLIDE, {
    1396         relatedTarget,
    1397         direction: eventDirectionName,
    1398         from: fromIndex,
    1399         to: targetIndex
    1400       });
    1401     }
    1402 
    1403     _setActiveIndicatorElement(element) {
    1404       if (this._indicatorsElement) {
    1405         const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE$1, this._indicatorsElement);
    1406         activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
    1407         activeIndicator.removeAttribute('aria-current');
    1408         const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
    1409 
    1410         for (let i = 0; i < indicators.length; i++) {
    1411           if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
    1412             indicators[i].classList.add(CLASS_NAME_ACTIVE$2);
    1413             indicators[i].setAttribute('aria-current', 'true');
    1414             break;
    1415           }
    1416         }
    1417       }
    1418     }
    1419 
    1420     _updateInterval() {
    1421       const element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
    1422 
    1423       if (!element) {
    1424         return;
    1425       }
    1426 
    1427       const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
    1428 
    1429       if (elementInterval) {
    1430         this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
    1431         this._config.interval = elementInterval;
    1432       } else {
    1433         this._config.interval = this._config.defaultInterval || this._config.interval;
    1434       }
    1435     }
    1436 
    1437     _slide(directionOrOrder, element) {
    1438       const order = this._directionToOrder(directionOrOrder);
    1439 
    1440       const activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
    1441 
    1442       const activeElementIndex = this._getItemIndex(activeElement);
    1443 
    1444       const nextElement = element || this._getItemByOrder(order, activeElement);
    1445 
    1446       const nextElementIndex = this._getItemIndex(nextElement);
    1447 
    1448       const isCycling = Boolean(this._interval);
    1449       const isNext = order === ORDER_NEXT;
    1450       const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
    1451       const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
    1452 
    1453       const eventDirectionName = this._orderToDirection(order);
    1454 
    1455       if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$2)) {
    1456         this._isSliding = false;
    1457         return;
    1458       }
    1459 
    1460       if (this._isSliding) {
    1461         return;
    1462       }
    1463 
    1464       const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
    1465 
    1466       if (slideEvent.defaultPrevented) {
    1467         return;
    1468       }
    1469 
    1470       if (!activeElement || !nextElement) {
    1471         // Some weirdness is happening, so we bail
    1472         return;
    1473       }
    1474 
    1475       this._isSliding = true;
    1476 
    1477       if (isCycling) {
    1478         this.pause();
    1479       }
    1480 
    1481       this._setActiveIndicatorElement(nextElement);
    1482 
    1483       this._activeElement = nextElement;
    1484 
    1485       const triggerSlidEvent = () => {
    1486         EventHandler.trigger(this._element, EVENT_SLID, {
    1487           relatedTarget: nextElement,
    1488           direction: eventDirectionName,
    1489           from: activeElementIndex,
    1490           to: nextElementIndex
    1491         });
    1492       };
    1493 
    1494       if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
    1495         nextElement.classList.add(orderClassName);
    1496         reflow(nextElement);
    1497         activeElement.classList.add(directionalClassName);
    1498         nextElement.classList.add(directionalClassName);
    1499 
    1500         const completeCallBack = () => {
    1501           nextElement.classList.remove(directionalClassName, orderClassName);
    1502           nextElement.classList.add(CLASS_NAME_ACTIVE$2);
    1503           activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
    1504           this._isSliding = false;
    1505           setTimeout(triggerSlidEvent, 0);
    1506         };
    1507 
    1508         this._queueCallback(completeCallBack, activeElement, true);
    1509       } else {
    1510         activeElement.classList.remove(CLASS_NAME_ACTIVE$2);
    1511         nextElement.classList.add(CLASS_NAME_ACTIVE$2);
    1512         this._isSliding = false;
    1513         triggerSlidEvent();
    1514       }
    1515 
    1516       if (isCycling) {
    1517         this.cycle();
    1518       }
    1519     }
    1520 
    1521     _directionToOrder(direction) {
    1522       if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
    1523         return direction;
    1524       }
    1525 
    1526       if (isRTL()) {
    1527         return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
    1528       }
    1529 
    1530       return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
    1531     }
    1532 
    1533     _orderToDirection(order) {
    1534       if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
    1535         return order;
    1536       }
    1537 
    1538       if (isRTL()) {
    1539         return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
    1540       }
    1541 
    1542       return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
    1543     } // Static
    1544 
    1545 
    1546     static carouselInterface(element, config) {
    1547       const data = Carousel.getOrCreateInstance(element, config);
    1548       let {
    1549         _config
    1550       } = data;
    1551 
    1552       if (typeof config === 'object') {
    1553         _config = { ..._config,
    1554           ...config
    1555         };
    1556       }
    1557 
    1558       const action = typeof config === 'string' ? config : _config.slide;
    1559 
    1560       if (typeof config === 'number') {
    1561         data.to(config);
    1562       } else if (typeof action === 'string') {
    1563         if (typeof data[action] === 'undefined') {
    1564           throw new TypeError(`No method named "${action}"`);
    1565         }
    1566 
    1567         data[action]();
    1568       } else if (_config.interval && _config.ride) {
    1569         data.pause();
    1570         data.cycle();
    1571       }
    1572     }
    1573 
    1574     static jQueryInterface(config) {
    1575       return this.each(function () {
    1576         Carousel.carouselInterface(this, config);
    1577       });
    1578     }
    1579 
    1580     static dataApiClickHandler(event) {
    1581       const target = getElementFromSelector(this);
    1582 
    1583       if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
    1584         return;
    1585       }
    1586 
    1587       const config = { ...Manipulator.getDataAttributes(target),
    1588         ...Manipulator.getDataAttributes(this)
    1589       };
    1590       const slideIndex = this.getAttribute('data-bs-slide-to');
    1591 
    1592       if (slideIndex) {
    1593         config.interval = false;
    1594       }
    1595 
    1596       Carousel.carouselInterface(target, config);
    1597 
    1598       if (slideIndex) {
    1599         Carousel.getInstance(target).to(slideIndex);
    1600       }
    1601 
    1602       event.preventDefault();
    1603     }
    1604 
    1605   }
    1606   /**
    1607    * ------------------------------------------------------------------------
    1608    * Data Api implementation
    1609    * ------------------------------------------------------------------------
    1610    */
    1611 
    1612 
    1613   EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
    1614   EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
    1615     const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
    1616 
    1617     for (let i = 0, len = carousels.length; i < len; i++) {
    1618       Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]));
    1619     }
    1620   });
    1621   /**
    1622    * ------------------------------------------------------------------------
    1623    * jQuery
    1624    * ------------------------------------------------------------------------
    1625    * add .Carousel to jQuery only if jQuery is present
    1626    */
    1627 
    1628   defineJQueryPlugin(Carousel);
    1629 
    1630   /**
    1631    * --------------------------------------------------------------------------
    1632    * Bootstrap (v5.1.3): collapse.js
    1633    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    1634    * --------------------------------------------------------------------------
    1635    */
    1636   /**
    1637    * ------------------------------------------------------------------------
    1638    * Constants
    1639    * ------------------------------------------------------------------------
    1640    */
    1641 
    1642   const NAME$a = 'collapse';
    1643   const DATA_KEY$9 = 'bs.collapse';
    1644   const EVENT_KEY$9 = `.${DATA_KEY$9}`;
    1645   const DATA_API_KEY$5 = '.data-api';
    1646   const Default$9 = {
    1647     toggle: true,
    1648     parent: null
    1649   };
    1650   const DefaultType$9 = {
    1651     toggle: 'boolean',
    1652     parent: '(null|element)'
    1653   };
    1654   const EVENT_SHOW$5 = `show${EVENT_KEY$9}`;
    1655   const EVENT_SHOWN$5 = `shown${EVENT_KEY$9}`;
    1656   const EVENT_HIDE$5 = `hide${EVENT_KEY$9}`;
    1657   const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$9}`;
    1658   const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$9}${DATA_API_KEY$5}`;
    1659   const CLASS_NAME_SHOW$7 = 'show';
    1660   const CLASS_NAME_COLLAPSE = 'collapse';
    1661   const CLASS_NAME_COLLAPSING = 'collapsing';
    1662   const CLASS_NAME_COLLAPSED = 'collapsed';
    1663   const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
    1664   const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
    1665   const WIDTH = 'width';
    1666   const HEIGHT = 'height';
    1667   const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
    1668   const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
    1669   /**
    1670    * ------------------------------------------------------------------------
    1671    * Class Definition
    1672    * ------------------------------------------------------------------------
    1673    */
    1674 
    1675   class Collapse extends BaseComponent {
    1676     constructor(element, config) {
    1677       super(element);
    1678       this._isTransitioning = false;
    1679       this._config = this._getConfig(config);
    1680       this._triggerArray = [];
    1681       const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
    1682 
    1683       for (let i = 0, len = toggleList.length; i < len; i++) {
    1684         const elem = toggleList[i];
    1685         const selector = getSelectorFromElement(elem);
    1686         const filterElement = SelectorEngine.find(selector).filter(foundElem => foundElem === this._element);
    1687 
    1688         if (selector !== null && filterElement.length) {
    1689           this._selector = selector;
    1690 
    1691           this._triggerArray.push(elem);
    1692         }
    1693       }
    1694 
    1695       this._initializeChildren();
    1696 
    1697       if (!this._config.parent) {
    1698         this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
    1699       }
    1700 
    1701       if (this._config.toggle) {
    1702         this.toggle();
    1703       }
    1704     } // Getters
    1705 
    1706 
    1707     static get Default() {
    1708       return Default$9;
    1709     }
    1710 
    1711     static get NAME() {
    1712       return NAME$a;
    1713     } // Public
    1714 
    1715 
    1716     toggle() {
    1717       if (this._isShown()) {
    1718         this.hide();
    1719       } else {
    1720         this.show();
    1721       }
    1722     }
    1723 
    1724     show() {
    1725       if (this._isTransitioning || this._isShown()) {
    1726         return;
    1727       }
    1728 
    1729       let actives = [];
    1730       let activesData;
    1731 
    1732       if (this._config.parent) {
    1733         const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
    1734         actives = SelectorEngine.find(SELECTOR_ACTIVES, this._config.parent).filter(elem => !children.includes(elem)); // remove children if greater depth
    1735       }
    1736 
    1737       const container = SelectorEngine.findOne(this._selector);
    1738 
    1739       if (actives.length) {
    1740         const tempActiveData = actives.find(elem => container !== elem);
    1741         activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
    1742 
    1743         if (activesData && activesData._isTransitioning) {
    1744           return;
    1745         }
    1746       }
    1747 
    1748       const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$5);
    1749 
    1750       if (startEvent.defaultPrevented) {
    1751         return;
    1752       }
    1753 
    1754       actives.forEach(elemActive => {
    1755         if (container !== elemActive) {
    1756           Collapse.getOrCreateInstance(elemActive, {
    1757             toggle: false
    1758           }).hide();
    1759         }
    1760 
    1761         if (!activesData) {
    1762           Data.set(elemActive, DATA_KEY$9, null);
    1763         }
    1764       });
    1765 
    1766       const dimension = this._getDimension();
    1767 
    1768       this._element.classList.remove(CLASS_NAME_COLLAPSE);
    1769 
    1770       this._element.classList.add(CLASS_NAME_COLLAPSING);
    1771 
    1772       this._element.style[dimension] = 0;
    1773 
    1774       this._addAriaAndCollapsedClass(this._triggerArray, true);
    1775 
    1776       this._isTransitioning = true;
    1777 
    1778       const complete = () => {
    1779         this._isTransitioning = false;
    1780 
    1781         this._element.classList.remove(CLASS_NAME_COLLAPSING);
    1782 
    1783         this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
    1784 
    1785         this._element.style[dimension] = '';
    1786         EventHandler.trigger(this._element, EVENT_SHOWN$5);
    1787       };
    1788 
    1789       const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
    1790       const scrollSize = `scroll${capitalizedDimension}`;
    1791 
    1792       this._queueCallback(complete, this._element, true);
    1793 
    1794       this._element.style[dimension] = `${this._element[scrollSize]}px`;
    1795     }
    1796 
    1797     hide() {
    1798       if (this._isTransitioning || !this._isShown()) {
    1799         return;
    1800       }
    1801 
    1802       const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$5);
    1803 
    1804       if (startEvent.defaultPrevented) {
    1805         return;
    1806       }
    1807 
    1808       const dimension = this._getDimension();
    1809 
    1810       this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
    1811       reflow(this._element);
    1812 
    1813       this._element.classList.add(CLASS_NAME_COLLAPSING);
    1814 
    1815       this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
    1816 
    1817       const triggerArrayLength = this._triggerArray.length;
    1818 
    1819       for (let i = 0; i < triggerArrayLength; i++) {
    1820         const trigger = this._triggerArray[i];
    1821         const elem = getElementFromSelector(trigger);
    1822 
    1823         if (elem && !this._isShown(elem)) {
    1824           this._addAriaAndCollapsedClass([trigger], false);
    1825         }
    1826       }
    1827 
    1828       this._isTransitioning = true;
    1829 
    1830       const complete = () => {
    1831         this._isTransitioning = false;
    1832 
    1833         this._element.classList.remove(CLASS_NAME_COLLAPSING);
    1834 
    1835         this._element.classList.add(CLASS_NAME_COLLAPSE);
    1836 
    1837         EventHandler.trigger(this._element, EVENT_HIDDEN$5);
    1838       };
    1839 
    1840       this._element.style[dimension] = '';
    1841 
    1842       this._queueCallback(complete, this._element, true);
    1843     }
    1844 
    1845     _isShown(element = this._element) {
    1846       return element.classList.contains(CLASS_NAME_SHOW$7);
    1847     } // Private
    1848 
    1849 
    1850     _getConfig(config) {
    1851       config = { ...Default$9,
    1852         ...Manipulator.getDataAttributes(this._element),
    1853         ...config
    1854       };
    1855       config.toggle = Boolean(config.toggle); // Coerce string values
    1856 
    1857       config.parent = getElement(config.parent);
    1858       typeCheckConfig(NAME$a, config, DefaultType$9);
    1859       return config;
    1860     }
    1861 
    1862     _getDimension() {
    1863       return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
    1864     }
    1865 
    1866     _initializeChildren() {
    1867       if (!this._config.parent) {
    1868         return;
    1869       }
    1870 
    1871       const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
    1872       SelectorEngine.find(SELECTOR_DATA_TOGGLE$4, this._config.parent).filter(elem => !children.includes(elem)).forEach(element => {
    1873         const selected = getElementFromSelector(element);
    1874 
    1875         if (selected) {
    1876           this._addAriaAndCollapsedClass([element], this._isShown(selected));
    1877         }
    1878       });
    1879     }
    1880 
    1881     _addAriaAndCollapsedClass(triggerArray, isOpen) {
    1882       if (!triggerArray.length) {
    1883         return;
    1884       }
    1885 
    1886       triggerArray.forEach(elem => {
    1887         if (isOpen) {
    1888           elem.classList.remove(CLASS_NAME_COLLAPSED);
    1889         } else {
    1890           elem.classList.add(CLASS_NAME_COLLAPSED);
    1891         }
    1892 
    1893         elem.setAttribute('aria-expanded', isOpen);
    1894       });
    1895     } // Static
    1896 
    1897 
    1898     static jQueryInterface(config) {
    1899       return this.each(function () {
    1900         const _config = {};
    1901 
    1902         if (typeof config === 'string' && /show|hide/.test(config)) {
    1903           _config.toggle = false;
    1904         }
    1905 
    1906         const data = Collapse.getOrCreateInstance(this, _config);
    1907 
    1908         if (typeof config === 'string') {
    1909           if (typeof data[config] === 'undefined') {
    1910             throw new TypeError(`No method named "${config}"`);
    1911           }
    1912 
    1913           data[config]();
    1914         }
    1915       });
    1916     }
    1917 
    1918   }
    1919   /**
    1920    * ------------------------------------------------------------------------
    1921    * Data Api implementation
    1922    * ------------------------------------------------------------------------
    1923    */
    1924 
    1925 
    1926   EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
    1927     // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
    1928     if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
    1929       event.preventDefault();
    1930     }
    1931 
    1932     const selector = getSelectorFromElement(this);
    1933     const selectorElements = SelectorEngine.find(selector);
    1934     selectorElements.forEach(element => {
    1935       Collapse.getOrCreateInstance(element, {
    1936         toggle: false
    1937       }).toggle();
    1938     });
    1939   });
    1940   /**
    1941    * ------------------------------------------------------------------------
    1942    * jQuery
    1943    * ------------------------------------------------------------------------
    1944    * add .Collapse to jQuery only if jQuery is present
    1945    */
    1946 
    1947   defineJQueryPlugin(Collapse);
    1948 
    1949   /**
    1950    * --------------------------------------------------------------------------
    1951    * Bootstrap (v5.1.3): dropdown.js
    1952    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    1953    * --------------------------------------------------------------------------
    1954    */
    1955   /**
    1956    * ------------------------------------------------------------------------
    1957    * Constants
    1958    * ------------------------------------------------------------------------
    1959    */
    1960 
    1961   const NAME$9 = 'dropdown';
    1962   const DATA_KEY$8 = 'bs.dropdown';
    1963   const EVENT_KEY$8 = `.${DATA_KEY$8}`;
    1964   const DATA_API_KEY$4 = '.data-api';
    1965   const ESCAPE_KEY$2 = 'Escape';
    1966   const SPACE_KEY = 'Space';
    1967   const TAB_KEY$1 = 'Tab';
    1968   const ARROW_UP_KEY = 'ArrowUp';
    1969   const ARROW_DOWN_KEY = 'ArrowDown';
    1970   const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
    1971 
    1972   const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY$2}`);
    1973   const EVENT_HIDE$4 = `hide${EVENT_KEY$8}`;
    1974   const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$8}`;
    1975   const EVENT_SHOW$4 = `show${EVENT_KEY$8}`;
    1976   const EVENT_SHOWN$4 = `shown${EVENT_KEY$8}`;
    1977   const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$8}${DATA_API_KEY$4}`;
    1978   const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$8}${DATA_API_KEY$4}`;
    1979   const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$8}${DATA_API_KEY$4}`;
    1980   const CLASS_NAME_SHOW$6 = 'show';
    1981   const CLASS_NAME_DROPUP = 'dropup';
    1982   const CLASS_NAME_DROPEND = 'dropend';
    1983   const CLASS_NAME_DROPSTART = 'dropstart';
    1984   const CLASS_NAME_NAVBAR = 'navbar';
    1985   const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]';
    1986   const SELECTOR_MENU = '.dropdown-menu';
    1987   const SELECTOR_NAVBAR_NAV = '.navbar-nav';
    1988   const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
    1989   const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
    1990   const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
    1991   const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
    1992   const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
    1993   const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
    1994   const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
    1995   const Default$8 = {
    1996     offset: [0, 2],
    1997     boundary: 'clippingParents',
    1998     reference: 'toggle',
    1999     display: 'dynamic',
    2000     popperConfig: null,
    2001     autoClose: true
    2002   };
    2003   const DefaultType$8 = {
    2004     offset: '(array|string|function)',
    2005     boundary: '(string|element)',
    2006     reference: '(string|element|object)',
    2007     display: 'string',
    2008     popperConfig: '(null|object|function)',
    2009     autoClose: '(boolean|string)'
    2010   };
    2011   /**
    2012    * ------------------------------------------------------------------------
    2013    * Class Definition
    2014    * ------------------------------------------------------------------------
    2015    */
    2016 
    2017   class Dropdown extends BaseComponent {
    2018     constructor(element, config) {
    2019       super(element);
    2020       this._popper = null;
    2021       this._config = this._getConfig(config);
    2022       this._menu = this._getMenuElement();
    2023       this._inNavbar = this._detectNavbar();
    2024     } // Getters
    2025 
    2026 
    2027     static get Default() {
    2028       return Default$8;
    2029     }
    2030 
    2031     static get DefaultType() {
    2032       return DefaultType$8;
    2033     }
    2034 
    2035     static get NAME() {
    2036       return NAME$9;
    2037     } // Public
    2038 
    2039 
    2040     toggle() {
    2041       return this._isShown() ? this.hide() : this.show();
    2042     }
    2043 
    2044     show() {
    2045       if (isDisabled(this._element) || this._isShown(this._menu)) {
    2046         return;
    2047       }
    2048 
    2049       const relatedTarget = {
    2050         relatedTarget: this._element
    2051       };
    2052       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, relatedTarget);
    2053 
    2054       if (showEvent.defaultPrevented) {
    2055         return;
    2056       }
    2057 
    2058       const parent = Dropdown.getParentFromElement(this._element); // Totally disable Popper for Dropdowns in Navbar
    2059 
    2060       if (this._inNavbar) {
    2061         Manipulator.setDataAttribute(this._menu, 'popper', 'none');
    2062       } else {
    2063         this._createPopper(parent);
    2064       } // If this is a touch-enabled device we add extra
    2065       // empty mouseover listeners to the body's immediate children;
    2066       // only needed because of broken event delegation on iOS
    2067       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
    2068 
    2069 
    2070       if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) {
    2071         [].concat(...document.body.children).forEach(elem => EventHandler.on(elem, 'mouseover', noop));
    2072       }
    2073 
    2074       this._element.focus();
    2075 
    2076       this._element.setAttribute('aria-expanded', true);
    2077 
    2078       this._menu.classList.add(CLASS_NAME_SHOW$6);
    2079 
    2080       this._element.classList.add(CLASS_NAME_SHOW$6);
    2081 
    2082       EventHandler.trigger(this._element, EVENT_SHOWN$4, relatedTarget);
    2083     }
    2084 
    2085     hide() {
    2086       if (isDisabled(this._element) || !this._isShown(this._menu)) {
    2087         return;
    2088       }
    2089 
    2090       const relatedTarget = {
    2091         relatedTarget: this._element
    2092       };
    2093 
    2094       this._completeHide(relatedTarget);
    2095     }
    2096 
    2097     dispose() {
    2098       if (this._popper) {
    2099         this._popper.destroy();
    2100       }
    2101 
    2102       super.dispose();
    2103     }
    2104 
    2105     update() {
    2106       this._inNavbar = this._detectNavbar();
    2107 
    2108       if (this._popper) {
    2109         this._popper.update();
    2110       }
    2111     } // Private
    2112 
    2113 
    2114     _completeHide(relatedTarget) {
    2115       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget);
    2116 
    2117       if (hideEvent.defaultPrevented) {
    2118         return;
    2119       } // If this is a touch-enabled device we remove the extra
    2120       // empty mouseover listeners we added for iOS support
    2121 
    2122 
    2123       if ('ontouchstart' in document.documentElement) {
    2124         [].concat(...document.body.children).forEach(elem => EventHandler.off(elem, 'mouseover', noop));
    2125       }
    2126 
    2127       if (this._popper) {
    2128         this._popper.destroy();
    2129       }
    2130 
    2131       this._menu.classList.remove(CLASS_NAME_SHOW$6);
    2132 
    2133       this._element.classList.remove(CLASS_NAME_SHOW$6);
    2134 
    2135       this._element.setAttribute('aria-expanded', 'false');
    2136 
    2137       Manipulator.removeDataAttribute(this._menu, 'popper');
    2138       EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget);
    2139     }
    2140 
    2141     _getConfig(config) {
    2142       config = { ...this.constructor.Default,
    2143         ...Manipulator.getDataAttributes(this._element),
    2144         ...config
    2145       };
    2146       typeCheckConfig(NAME$9, config, this.constructor.DefaultType);
    2147 
    2148       if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
    2149         // Popper virtual elements require a getBoundingClientRect method
    2150         throw new TypeError(`${NAME$9.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
    2151       }
    2152 
    2153       return config;
    2154     }
    2155 
    2156     _createPopper(parent) {
    2157       if (typeof Popper__namespace === 'undefined') {
    2158         throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
    2159       }
    2160 
    2161       let referenceElement = this._element;
    2162 
    2163       if (this._config.reference === 'parent') {
    2164         referenceElement = parent;
    2165       } else if (isElement(this._config.reference)) {
    2166         referenceElement = getElement(this._config.reference);
    2167       } else if (typeof this._config.reference === 'object') {
    2168         referenceElement = this._config.reference;
    2169       }
    2170 
    2171       const popperConfig = this._getPopperConfig();
    2172 
    2173       const isDisplayStatic = popperConfig.modifiers.find(modifier => modifier.name === 'applyStyles' && modifier.enabled === false);
    2174       this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);
    2175 
    2176       if (isDisplayStatic) {
    2177         Manipulator.setDataAttribute(this._menu, 'popper', 'static');
    2178       }
    2179     }
    2180 
    2181     _isShown(element = this._element) {
    2182       return element.classList.contains(CLASS_NAME_SHOW$6);
    2183     }
    2184 
    2185     _getMenuElement() {
    2186       return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
    2187     }
    2188 
    2189     _getPlacement() {
    2190       const parentDropdown = this._element.parentNode;
    2191 
    2192       if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
    2193         return PLACEMENT_RIGHT;
    2194       }
    2195 
    2196       if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
    2197         return PLACEMENT_LEFT;
    2198       } // We need to trim the value because custom properties can also include spaces
    2199 
    2200 
    2201       const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
    2202 
    2203       if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
    2204         return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
    2205       }
    2206 
    2207       return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
    2208     }
    2209 
    2210     _detectNavbar() {
    2211       return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
    2212     }
    2213 
    2214     _getOffset() {
    2215       const {
    2216         offset
    2217       } = this._config;
    2218 
    2219       if (typeof offset === 'string') {
    2220         return offset.split(',').map(val => Number.parseInt(val, 10));
    2221       }
    2222 
    2223       if (typeof offset === 'function') {
    2224         return popperData => offset(popperData, this._element);
    2225       }
    2226 
    2227       return offset;
    2228     }
    2229 
    2230     _getPopperConfig() {
    2231       const defaultBsPopperConfig = {
    2232         placement: this._getPlacement(),
    2233         modifiers: [{
    2234           name: 'preventOverflow',
    2235           options: {
    2236             boundary: this._config.boundary
    2237           }
    2238         }, {
    2239           name: 'offset',
    2240           options: {
    2241             offset: this._getOffset()
    2242           }
    2243         }]
    2244       }; // Disable Popper if we have a static display
    2245 
    2246       if (this._config.display === 'static') {
    2247         defaultBsPopperConfig.modifiers = [{
    2248           name: 'applyStyles',
    2249           enabled: false
    2250         }];
    2251       }
    2252 
    2253       return { ...defaultBsPopperConfig,
    2254         ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
    2255       };
    2256     }
    2257 
    2258     _selectMenuItem({
    2259       key,
    2260       target
    2261     }) {
    2262       const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
    2263 
    2264       if (!items.length) {
    2265         return;
    2266       } // if target isn't included in items (e.g. when expanding the dropdown)
    2267       // allow cycling to get the last item in case key equals ARROW_UP_KEY
    2268 
    2269 
    2270       getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus();
    2271     } // Static
    2272 
    2273 
    2274     static jQueryInterface(config) {
    2275       return this.each(function () {
    2276         const data = Dropdown.getOrCreateInstance(this, config);
    2277 
    2278         if (typeof config !== 'string') {
    2279           return;
    2280         }
    2281 
    2282         if (typeof data[config] === 'undefined') {
    2283           throw new TypeError(`No method named "${config}"`);
    2284         }
    2285 
    2286         data[config]();
    2287       });
    2288     }
    2289 
    2290     static clearMenus(event) {
    2291       if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1)) {
    2292         return;
    2293       }
    2294 
    2295       const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$3);
    2296 
    2297       for (let i = 0, len = toggles.length; i < len; i++) {
    2298         const context = Dropdown.getInstance(toggles[i]);
    2299 
    2300         if (!context || context._config.autoClose === false) {
    2301           continue;
    2302         }
    2303 
    2304         if (!context._isShown()) {
    2305           continue;
    2306         }
    2307 
    2308         const relatedTarget = {
    2309           relatedTarget: context._element
    2310         };
    2311 
    2312         if (event) {
    2313           const composedPath = event.composedPath();
    2314           const isMenuTarget = composedPath.includes(context._menu);
    2315 
    2316           if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
    2317             continue;
    2318           } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
    2319 
    2320 
    2321           if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
    2322             continue;
    2323           }
    2324 
    2325           if (event.type === 'click') {
    2326             relatedTarget.clickEvent = event;
    2327           }
    2328         }
    2329 
    2330         context._completeHide(relatedTarget);
    2331       }
    2332     }
    2333 
    2334     static getParentFromElement(element) {
    2335       return getElementFromSelector(element) || element.parentNode;
    2336     }
    2337 
    2338     static dataApiKeydownHandler(event) {
    2339       // If not input/textarea:
    2340       //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
    2341       // If input/textarea:
    2342       //  - If space key => not a dropdown command
    2343       //  - If key is other than escape
    2344       //    - If key is not up or down => not a dropdown command
    2345       //    - If trigger inside the menu => not a dropdown command
    2346       if (/input|textarea/i.test(event.target.tagName) ? event.key === SPACE_KEY || event.key !== ESCAPE_KEY$2 && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) {
    2347         return;
    2348       }
    2349 
    2350       const isActive = this.classList.contains(CLASS_NAME_SHOW$6);
    2351 
    2352       if (!isActive && event.key === ESCAPE_KEY$2) {
    2353         return;
    2354       }
    2355 
    2356       event.preventDefault();
    2357       event.stopPropagation();
    2358 
    2359       if (isDisabled(this)) {
    2360         return;
    2361       }
    2362 
    2363       const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
    2364       const instance = Dropdown.getOrCreateInstance(getToggleButton);
    2365 
    2366       if (event.key === ESCAPE_KEY$2) {
    2367         instance.hide();
    2368         return;
    2369       }
    2370 
    2371       if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
    2372         if (!isActive) {
    2373           instance.show();
    2374         }
    2375 
    2376         instance._selectMenuItem(event);
    2377 
    2378         return;
    2379       }
    2380 
    2381       if (!isActive || event.key === SPACE_KEY) {
    2382         Dropdown.clearMenus();
    2383       }
    2384     }
    2385 
    2386   }
    2387   /**
    2388    * ------------------------------------------------------------------------
    2389    * Data Api implementation
    2390    * ------------------------------------------------------------------------
    2391    */
    2392 
    2393 
    2394   EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
    2395   EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
    2396   EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
    2397   EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
    2398   EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
    2399     event.preventDefault();
    2400     Dropdown.getOrCreateInstance(this).toggle();
    2401   });
    2402   /**
    2403    * ------------------------------------------------------------------------
    2404    * jQuery
    2405    * ------------------------------------------------------------------------
    2406    * add .Dropdown to jQuery only if jQuery is present
    2407    */
    2408 
    2409   defineJQueryPlugin(Dropdown);
    2410 
    2411   /**
    2412    * --------------------------------------------------------------------------
    2413    * Bootstrap (v5.1.3): util/scrollBar.js
    2414    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    2415    * --------------------------------------------------------------------------
    2416    */
    2417   const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
    2418   const SELECTOR_STICKY_CONTENT = '.sticky-top';
    2419 
    2420   class ScrollBarHelper {
    2421     constructor() {
    2422       this._element = document.body;
    2423     }
    2424 
    2425     getWidth() {
    2426       // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
    2427       const documentWidth = document.documentElement.clientWidth;
    2428       return Math.abs(window.innerWidth - documentWidth);
    2429     }
    2430 
    2431     hide() {
    2432       const width = this.getWidth();
    2433 
    2434       this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width
    2435 
    2436 
    2437       this._setElementAttributes(this._element, 'paddingRight', calculatedValue => calculatedValue + width); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
    2438 
    2439 
    2440       this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width);
    2441 
    2442       this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width);
    2443     }
    2444 
    2445     _disableOverFlow() {
    2446       this._saveInitialAttribute(this._element, 'overflow');
    2447 
    2448       this._element.style.overflow = 'hidden';
    2449     }
    2450 
    2451     _setElementAttributes(selector, styleProp, callback) {
    2452       const scrollbarWidth = this.getWidth();
    2453 
    2454       const manipulationCallBack = element => {
    2455         if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
    2456           return;
    2457         }
    2458 
    2459         this._saveInitialAttribute(element, styleProp);
    2460 
    2461         const calculatedValue = window.getComputedStyle(element)[styleProp];
    2462         element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
    2463       };
    2464 
    2465       this._applyManipulationCallback(selector, manipulationCallBack);
    2466     }
    2467 
    2468     reset() {
    2469       this._resetElementAttributes(this._element, 'overflow');
    2470 
    2471       this._resetElementAttributes(this._element, 'paddingRight');
    2472 
    2473       this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
    2474 
    2475       this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
    2476     }
    2477 
    2478     _saveInitialAttribute(element, styleProp) {
    2479       const actualValue = element.style[styleProp];
    2480 
    2481       if (actualValue) {
    2482         Manipulator.setDataAttribute(element, styleProp, actualValue);
    2483       }
    2484     }
    2485 
    2486     _resetElementAttributes(selector, styleProp) {
    2487       const manipulationCallBack = element => {
    2488         const value = Manipulator.getDataAttribute(element, styleProp);
    2489 
    2490         if (typeof value === 'undefined') {
    2491           element.style.removeProperty(styleProp);
    2492         } else {
    2493           Manipulator.removeDataAttribute(element, styleProp);
    2494           element.style[styleProp] = value;
    2495         }
    2496       };
    2497 
    2498       this._applyManipulationCallback(selector, manipulationCallBack);
    2499     }
    2500 
    2501     _applyManipulationCallback(selector, callBack) {
    2502       if (isElement(selector)) {
    2503         callBack(selector);
    2504       } else {
    2505         SelectorEngine.find(selector, this._element).forEach(callBack);
    2506       }
    2507     }
    2508 
    2509     isOverflowing() {
    2510       return this.getWidth() > 0;
    2511     }
    2512 
    2513   }
    2514 
    2515   /**
    2516    * --------------------------------------------------------------------------
    2517    * Bootstrap (v5.1.3): util/backdrop.js
    2518    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    2519    * --------------------------------------------------------------------------
    2520    */
    2521   const Default$7 = {
    2522     className: 'modal-backdrop',
    2523     isVisible: true,
    2524     // if false, we use the backdrop helper without adding any element to the dom
    2525     isAnimated: false,
    2526     rootElement: 'body',
    2527     // give the choice to place backdrop under different elements
    2528     clickCallback: null
    2529   };
    2530   const DefaultType$7 = {
    2531     className: 'string',
    2532     isVisible: 'boolean',
    2533     isAnimated: 'boolean',
    2534     rootElement: '(element|string)',
    2535     clickCallback: '(function|null)'
    2536   };
    2537   const NAME$8 = 'backdrop';
    2538   const CLASS_NAME_FADE$4 = 'fade';
    2539   const CLASS_NAME_SHOW$5 = 'show';
    2540   const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$8}`;
    2541 
    2542   class Backdrop {
    2543     constructor(config) {
    2544       this._config = this._getConfig(config);
    2545       this._isAppended = false;
    2546       this._element = null;
    2547     }
    2548 
    2549     show(callback) {
    2550       if (!this._config.isVisible) {
    2551         execute(callback);
    2552         return;
    2553       }
    2554 
    2555       this._append();
    2556 
    2557       if (this._config.isAnimated) {
    2558         reflow(this._getElement());
    2559       }
    2560 
    2561       this._getElement().classList.add(CLASS_NAME_SHOW$5);
    2562 
    2563       this._emulateAnimation(() => {
    2564         execute(callback);
    2565       });
    2566     }
    2567 
    2568     hide(callback) {
    2569       if (!this._config.isVisible) {
    2570         execute(callback);
    2571         return;
    2572       }
    2573 
    2574       this._getElement().classList.remove(CLASS_NAME_SHOW$5);
    2575 
    2576       this._emulateAnimation(() => {
    2577         this.dispose();
    2578         execute(callback);
    2579       });
    2580     } // Private
    2581 
    2582 
    2583     _getElement() {
    2584       if (!this._element) {
    2585         const backdrop = document.createElement('div');
    2586         backdrop.className = this._config.className;
    2587 
    2588         if (this._config.isAnimated) {
    2589           backdrop.classList.add(CLASS_NAME_FADE$4);
    2590         }
    2591 
    2592         this._element = backdrop;
    2593       }
    2594 
    2595       return this._element;
    2596     }
    2597 
    2598     _getConfig(config) {
    2599       config = { ...Default$7,
    2600         ...(typeof config === 'object' ? config : {})
    2601       }; // use getElement() with the default "body" to get a fresh Element on each instantiation
    2602 
    2603       config.rootElement = getElement(config.rootElement);
    2604       typeCheckConfig(NAME$8, config, DefaultType$7);
    2605       return config;
    2606     }
    2607 
    2608     _append() {
    2609       if (this._isAppended) {
    2610         return;
    2611       }
    2612 
    2613       this._config.rootElement.append(this._getElement());
    2614 
    2615       EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, () => {
    2616         execute(this._config.clickCallback);
    2617       });
    2618       this._isAppended = true;
    2619     }
    2620 
    2621     dispose() {
    2622       if (!this._isAppended) {
    2623         return;
    2624       }
    2625 
    2626       EventHandler.off(this._element, EVENT_MOUSEDOWN);
    2627 
    2628       this._element.remove();
    2629 
    2630       this._isAppended = false;
    2631     }
    2632 
    2633     _emulateAnimation(callback) {
    2634       executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
    2635     }
    2636 
    2637   }
    2638 
    2639   /**
    2640    * --------------------------------------------------------------------------
    2641    * Bootstrap (v5.1.3): util/focustrap.js
    2642    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    2643    * --------------------------------------------------------------------------
    2644    */
    2645   const Default$6 = {
    2646     trapElement: null,
    2647     // The element to trap focus inside of
    2648     autofocus: true
    2649   };
    2650   const DefaultType$6 = {
    2651     trapElement: 'element',
    2652     autofocus: 'boolean'
    2653   };
    2654   const NAME$7 = 'focustrap';
    2655   const DATA_KEY$7 = 'bs.focustrap';
    2656   const EVENT_KEY$7 = `.${DATA_KEY$7}`;
    2657   const EVENT_FOCUSIN$1 = `focusin${EVENT_KEY$7}`;
    2658   const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$7}`;
    2659   const TAB_KEY = 'Tab';
    2660   const TAB_NAV_FORWARD = 'forward';
    2661   const TAB_NAV_BACKWARD = 'backward';
    2662 
    2663   class FocusTrap {
    2664     constructor(config) {
    2665       this._config = this._getConfig(config);
    2666       this._isActive = false;
    2667       this._lastTabNavDirection = null;
    2668     }
    2669 
    2670     activate() {
    2671       const {
    2672         trapElement,
    2673         autofocus
    2674       } = this._config;
    2675 
    2676       if (this._isActive) {
    2677         return;
    2678       }
    2679 
    2680       if (autofocus) {
    2681         trapElement.focus();
    2682       }
    2683 
    2684       EventHandler.off(document, EVENT_KEY$7); // guard against infinite focus loop
    2685 
    2686       EventHandler.on(document, EVENT_FOCUSIN$1, event => this._handleFocusin(event));
    2687       EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
    2688       this._isActive = true;
    2689     }
    2690 
    2691     deactivate() {
    2692       if (!this._isActive) {
    2693         return;
    2694       }
    2695 
    2696       this._isActive = false;
    2697       EventHandler.off(document, EVENT_KEY$7);
    2698     } // Private
    2699 
    2700 
    2701     _handleFocusin(event) {
    2702       const {
    2703         target
    2704       } = event;
    2705       const {
    2706         trapElement
    2707       } = this._config;
    2708 
    2709       if (target === document || target === trapElement || trapElement.contains(target)) {
    2710         return;
    2711       }
    2712 
    2713       const elements = SelectorEngine.focusableChildren(trapElement);
    2714 
    2715       if (elements.length === 0) {
    2716         trapElement.focus();
    2717       } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
    2718         elements[elements.length - 1].focus();
    2719       } else {
    2720         elements[0].focus();
    2721       }
    2722     }
    2723 
    2724     _handleKeydown(event) {
    2725       if (event.key !== TAB_KEY) {
    2726         return;
    2727       }
    2728 
    2729       this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
    2730     }
    2731 
    2732     _getConfig(config) {
    2733       config = { ...Default$6,
    2734         ...(typeof config === 'object' ? config : {})
    2735       };
    2736       typeCheckConfig(NAME$7, config, DefaultType$6);
    2737       return config;
    2738     }
    2739 
    2740   }
    2741 
    2742   /**
    2743    * --------------------------------------------------------------------------
    2744    * Bootstrap (v5.1.3): modal.js
    2745    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    2746    * --------------------------------------------------------------------------
    2747    */
    2748   /**
    2749    * ------------------------------------------------------------------------
    2750    * Constants
    2751    * ------------------------------------------------------------------------
    2752    */
    2753 
    2754   const NAME$6 = 'modal';
    2755   const DATA_KEY$6 = 'bs.modal';
    2756   const EVENT_KEY$6 = `.${DATA_KEY$6}`;
    2757   const DATA_API_KEY$3 = '.data-api';
    2758   const ESCAPE_KEY$1 = 'Escape';
    2759   const Default$5 = {
     341    keyboard: true
     342  }
     343
     344  Carousel.prototype.keydown = function (e) {
     345    if (/input|textarea/i.test(e.target.tagName)) return
     346    switch (e.which) {
     347      case 37: this.prev(); break
     348      case 39: this.next(); break
     349      default: return
     350    }
     351
     352    e.preventDefault()
     353  }
     354
     355  Carousel.prototype.cycle = function (e) {
     356    e || (this.paused = false)
     357
     358    this.interval && clearInterval(this.interval)
     359
     360    this.options.interval
     361      && !this.paused
     362      && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
     363
     364    return this
     365  }
     366
     367  Carousel.prototype.getItemIndex = function (item) {
     368    this.$items = item.parent().children('.item')
     369    return this.$items.index(item || this.$active)
     370  }
     371
     372  Carousel.prototype.getItemForDirection = function (direction, active) {
     373    var activeIndex = this.getItemIndex(active)
     374    var willWrap = (direction == 'prev' && activeIndex === 0)
     375                || (direction == 'next' && activeIndex == (this.$items.length - 1))
     376    if (willWrap && !this.options.wrap) return active
     377    var delta = direction == 'prev' ? -1 : 1
     378    var itemIndex = (activeIndex + delta) % this.$items.length
     379    return this.$items.eq(itemIndex)
     380  }
     381
     382  Carousel.prototype.to = function (pos) {
     383    var that        = this
     384    var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))
     385
     386    if (pos > (this.$items.length - 1) || pos < 0) return
     387
     388    if (this.sliding)       return this.$element.one('slid.bs.carousel', function () { that.to(pos) }) // yes, "slid"
     389    if (activeIndex == pos) return this.pause().cycle()
     390
     391    return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos))
     392  }
     393
     394  Carousel.prototype.pause = function (e) {
     395    e || (this.paused = true)
     396
     397    if (this.$element.find('.next, .prev').length && $.support.transition) {
     398      this.$element.trigger($.support.transition.end)
     399      this.cycle(true)
     400    }
     401
     402    this.interval = clearInterval(this.interval)
     403
     404    return this
     405  }
     406
     407  Carousel.prototype.next = function () {
     408    if (this.sliding) return
     409    return this.slide('next')
     410  }
     411
     412  Carousel.prototype.prev = function () {
     413    if (this.sliding) return
     414    return this.slide('prev')
     415  }
     416
     417  Carousel.prototype.slide = function (type, next) {
     418    var $active   = this.$element.find('.item.active')
     419    var $next     = next || this.getItemForDirection(type, $active)
     420    var isCycling = this.interval
     421    var direction = type == 'next' ? 'left' : 'right'
     422    var that      = this
     423
     424    if ($next.hasClass('active')) return (this.sliding = false)
     425
     426    var relatedTarget = $next[0]
     427    var slideEvent = $.Event('slide.bs.carousel', {
     428      relatedTarget: relatedTarget,
     429      direction: direction
     430    })
     431    this.$element.trigger(slideEvent)
     432    if (slideEvent.isDefaultPrevented()) return
     433
     434    this.sliding = true
     435
     436    isCycling && this.pause()
     437
     438    if (this.$indicators.length) {
     439      this.$indicators.find('.active').removeClass('active')
     440      var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])
     441      $nextIndicator && $nextIndicator.addClass('active')
     442    }
     443
     444    var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }) // yes, "slid"
     445    if ($.support.transition && this.$element.hasClass('slide')) {
     446      $next.addClass(type)
     447      if (typeof $next === 'object' && $next.length) {
     448        $next[0].offsetWidth // force reflow
     449      }
     450      $active.addClass(direction)
     451      $next.addClass(direction)
     452      $active
     453        .one('bsTransitionEnd', function () {
     454          $next.removeClass([type, direction].join(' ')).addClass('active')
     455          $active.removeClass(['active', direction].join(' '))
     456          that.sliding = false
     457          setTimeout(function () {
     458            that.$element.trigger(slidEvent)
     459          }, 0)
     460        })
     461        .emulateTransitionEnd(Carousel.TRANSITION_DURATION)
     462    } else {
     463      $active.removeClass('active')
     464      $next.addClass('active')
     465      this.sliding = false
     466      this.$element.trigger(slidEvent)
     467    }
     468
     469    isCycling && this.cycle()
     470
     471    return this
     472  }
     473
     474
     475  // CAROUSEL PLUGIN DEFINITION
     476  // ==========================
     477
     478  function Plugin(option) {
     479    return this.each(function () {
     480      var $this   = $(this)
     481      var data    = $this.data('bs.carousel')
     482      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
     483      var action  = typeof option == 'string' ? option : options.slide
     484
     485      if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))
     486      if (typeof option == 'number') data.to(option)
     487      else if (action) data[action]()
     488      else if (options.interval) data.pause().cycle()
     489    })
     490  }
     491
     492  var old = $.fn.carousel
     493
     494  $.fn.carousel             = Plugin
     495  $.fn.carousel.Constructor = Carousel
     496
     497
     498  // CAROUSEL NO CONFLICT
     499  // ====================
     500
     501  $.fn.carousel.noConflict = function () {
     502    $.fn.carousel = old
     503    return this
     504  }
     505
     506
     507  // CAROUSEL DATA-API
     508  // =================
     509
     510  var clickHandler = function (e) {
     511    var $this   = $(this)
     512    var href    = $this.attr('href')
     513    if (href) {
     514      href = href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
     515    }
     516
     517    var target  = $this.attr('data-target') || href
     518    var $target = $(document).find(target)
     519
     520    if (!$target.hasClass('carousel')) return
     521
     522    var options = $.extend({}, $target.data(), $this.data())
     523    var slideIndex = $this.attr('data-slide-to')
     524    if (slideIndex) options.interval = false
     525
     526    Plugin.call($target, options)
     527
     528    if (slideIndex) {
     529      $target.data('bs.carousel').to(slideIndex)
     530    }
     531
     532    e.preventDefault()
     533  }
     534
     535  $(document)
     536    .on('click.bs.carousel.data-api', '[data-slide]', clickHandler)
     537    .on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)
     538
     539  $(window).on('load', function () {
     540    $('[data-ride="carousel"]').each(function () {
     541      var $carousel = $(this)
     542      Plugin.call($carousel, $carousel.data())
     543    })
     544  })
     545
     546}(jQuery);
     547
     548/* ========================================================================
     549 * Bootstrap: collapse.js v3.4.1
     550 * https://getbootstrap.com/docs/3.4/javascript/#collapse
     551 * ========================================================================
     552 * Copyright 2011-2019 Twitter, Inc.
     553 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     554 * ======================================================================== */
     555
     556/* jshint latedef: false */
     557
     558+function ($) {
     559  'use strict';
     560
     561  // COLLAPSE PUBLIC CLASS DEFINITION
     562  // ================================
     563
     564  var Collapse = function (element, options) {
     565    this.$element      = $(element)
     566    this.options       = $.extend({}, Collapse.DEFAULTS, options)
     567    this.$trigger      = $('[data-toggle="collapse"][href="#' + element.id + '"],' +
     568                           '[data-toggle="collapse"][data-target="#' + element.id + '"]')
     569    this.transitioning = null
     570
     571    if (this.options.parent) {
     572      this.$parent = this.getParent()
     573    } else {
     574      this.addAriaAndCollapsedClass(this.$element, this.$trigger)
     575    }
     576
     577    if (this.options.toggle) this.toggle()
     578  }
     579
     580  Collapse.VERSION  = '3.4.1'
     581
     582  Collapse.TRANSITION_DURATION = 350
     583
     584  Collapse.DEFAULTS = {
     585    toggle: true
     586  }
     587
     588  Collapse.prototype.dimension = function () {
     589    var hasWidth = this.$element.hasClass('width')
     590    return hasWidth ? 'width' : 'height'
     591  }
     592
     593  Collapse.prototype.show = function () {
     594    if (this.transitioning || this.$element.hasClass('in')) return
     595
     596    var activesData
     597    var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')
     598
     599    if (actives && actives.length) {
     600      activesData = actives.data('bs.collapse')
     601      if (activesData && activesData.transitioning) return
     602    }
     603
     604    var startEvent = $.Event('show.bs.collapse')
     605    this.$element.trigger(startEvent)
     606    if (startEvent.isDefaultPrevented()) return
     607
     608    if (actives && actives.length) {
     609      Plugin.call(actives, 'hide')
     610      activesData || actives.data('bs.collapse', null)
     611    }
     612
     613    var dimension = this.dimension()
     614
     615    this.$element
     616      .removeClass('collapse')
     617      .addClass('collapsing')[dimension](0)
     618      .attr('aria-expanded', true)
     619
     620    this.$trigger
     621      .removeClass('collapsed')
     622      .attr('aria-expanded', true)
     623
     624    this.transitioning = 1
     625
     626    var complete = function () {
     627      this.$element
     628        .removeClass('collapsing')
     629        .addClass('collapse in')[dimension]('')
     630      this.transitioning = 0
     631      this.$element
     632        .trigger('shown.bs.collapse')
     633    }
     634
     635    if (!$.support.transition) return complete.call(this)
     636
     637    var scrollSize = $.camelCase(['scroll', dimension].join('-'))
     638
     639    this.$element
     640      .one('bsTransitionEnd', $.proxy(complete, this))
     641      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])
     642  }
     643
     644  Collapse.prototype.hide = function () {
     645    if (this.transitioning || !this.$element.hasClass('in')) return
     646
     647    var startEvent = $.Event('hide.bs.collapse')
     648    this.$element.trigger(startEvent)
     649    if (startEvent.isDefaultPrevented()) return
     650
     651    var dimension = this.dimension()
     652
     653    this.$element[dimension](this.$element[dimension]())[0].offsetHeight
     654
     655    this.$element
     656      .addClass('collapsing')
     657      .removeClass('collapse in')
     658      .attr('aria-expanded', false)
     659
     660    this.$trigger
     661      .addClass('collapsed')
     662      .attr('aria-expanded', false)
     663
     664    this.transitioning = 1
     665
     666    var complete = function () {
     667      this.transitioning = 0
     668      this.$element
     669        .removeClass('collapsing')
     670        .addClass('collapse')
     671        .trigger('hidden.bs.collapse')
     672    }
     673
     674    if (!$.support.transition) return complete.call(this)
     675
     676    this.$element
     677      [dimension](0)
     678      .one('bsTransitionEnd', $.proxy(complete, this))
     679      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)
     680  }
     681
     682  Collapse.prototype.toggle = function () {
     683    this[this.$element.hasClass('in') ? 'hide' : 'show']()
     684  }
     685
     686  Collapse.prototype.getParent = function () {
     687    return $(document).find(this.options.parent)
     688      .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
     689      .each($.proxy(function (i, element) {
     690        var $element = $(element)
     691        this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)
     692      }, this))
     693      .end()
     694  }
     695
     696  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
     697    var isOpen = $element.hasClass('in')
     698
     699    $element.attr('aria-expanded', isOpen)
     700    $trigger
     701      .toggleClass('collapsed', !isOpen)
     702      .attr('aria-expanded', isOpen)
     703  }
     704
     705  function getTargetFromTrigger($trigger) {
     706    var href
     707    var target = $trigger.attr('data-target')
     708      || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
     709
     710    return $(document).find(target)
     711  }
     712
     713
     714  // COLLAPSE PLUGIN DEFINITION
     715  // ==========================
     716
     717  function Plugin(option) {
     718    return this.each(function () {
     719      var $this   = $(this)
     720      var data    = $this.data('bs.collapse')
     721      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
     722
     723      if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false
     724      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
     725      if (typeof option == 'string') data[option]()
     726    })
     727  }
     728
     729  var old = $.fn.collapse
     730
     731  $.fn.collapse             = Plugin
     732  $.fn.collapse.Constructor = Collapse
     733
     734
     735  // COLLAPSE NO CONFLICT
     736  // ====================
     737
     738  $.fn.collapse.noConflict = function () {
     739    $.fn.collapse = old
     740    return this
     741  }
     742
     743
     744  // COLLAPSE DATA-API
     745  // =================
     746
     747  $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
     748    var $this   = $(this)
     749
     750    if (!$this.attr('data-target')) e.preventDefault()
     751
     752    var $target = getTargetFromTrigger($this)
     753    var data    = $target.data('bs.collapse')
     754    var option  = data ? 'toggle' : $this.data()
     755
     756    Plugin.call($target, option)
     757  })
     758
     759}(jQuery);
     760
     761/* ========================================================================
     762 * Bootstrap: dropdown.js v3.4.1
     763 * https://getbootstrap.com/docs/3.4/javascript/#dropdowns
     764 * ========================================================================
     765 * Copyright 2011-2019 Twitter, Inc.
     766 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     767 * ======================================================================== */
     768
     769
     770+function ($) {
     771  'use strict';
     772
     773  // DROPDOWN CLASS DEFINITION
     774  // =========================
     775
     776  var backdrop = '.dropdown-backdrop'
     777  var toggle   = '[data-toggle="dropdown"]'
     778  var Dropdown = function (element) {
     779    $(element).on('click.bs.dropdown', this.toggle)
     780  }
     781
     782  Dropdown.VERSION = '3.4.1'
     783
     784  function getParent($this) {
     785    var selector = $this.attr('data-target')
     786
     787    if (!selector) {
     788      selector = $this.attr('href')
     789      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
     790    }
     791
     792    var $parent = selector !== '#' ? $(document).find(selector) : null
     793
     794    return $parent && $parent.length ? $parent : $this.parent()
     795  }
     796
     797  function clearMenus(e) {
     798    if (e && e.which === 3) return
     799    $(backdrop).remove()
     800    $(toggle).each(function () {
     801      var $this         = $(this)
     802      var $parent       = getParent($this)
     803      var relatedTarget = { relatedTarget: this }
     804
     805      if (!$parent.hasClass('open')) return
     806
     807      if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return
     808
     809      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
     810
     811      if (e.isDefaultPrevented()) return
     812
     813      $this.attr('aria-expanded', 'false')
     814      $parent.removeClass('open').trigger($.Event('hidden.bs.dropdown', relatedTarget))
     815    })
     816  }
     817
     818  Dropdown.prototype.toggle = function (e) {
     819    var $this = $(this)
     820
     821    if ($this.is('.disabled, :disabled')) return
     822
     823    var $parent  = getParent($this)
     824    var isActive = $parent.hasClass('open')
     825
     826    clearMenus()
     827
     828    if (!isActive) {
     829      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
     830        // if mobile we use a backdrop because click events don't delegate
     831        $(document.createElement('div'))
     832          .addClass('dropdown-backdrop')
     833          .insertAfter($(this))
     834          .on('click', clearMenus)
     835      }
     836
     837      var relatedTarget = { relatedTarget: this }
     838      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
     839
     840      if (e.isDefaultPrevented()) return
     841
     842      $this
     843        .trigger('focus')
     844        .attr('aria-expanded', 'true')
     845
     846      $parent
     847        .toggleClass('open')
     848        .trigger($.Event('shown.bs.dropdown', relatedTarget))
     849    }
     850
     851    return false
     852  }
     853
     854  Dropdown.prototype.keydown = function (e) {
     855    if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return
     856
     857    var $this = $(this)
     858
     859    e.preventDefault()
     860    e.stopPropagation()
     861
     862    if ($this.is('.disabled, :disabled')) return
     863
     864    var $parent  = getParent($this)
     865    var isActive = $parent.hasClass('open')
     866
     867    if (!isActive && e.which != 27 || isActive && e.which == 27) {
     868      if (e.which == 27) $parent.find(toggle).trigger('focus')
     869      return $this.trigger('click')
     870    }
     871
     872    var desc = ' li:not(.disabled):visible a'
     873    var $items = $parent.find('.dropdown-menu' + desc)
     874
     875    if (!$items.length) return
     876
     877    var index = $items.index(e.target)
     878
     879    if (e.which == 38 && index > 0)                 index--         // up
     880    if (e.which == 40 && index < $items.length - 1) index++         // down
     881    if (!~index)                                    index = 0
     882
     883    $items.eq(index).trigger('focus')
     884  }
     885
     886
     887  // DROPDOWN PLUGIN DEFINITION
     888  // ==========================
     889
     890  function Plugin(option) {
     891    return this.each(function () {
     892      var $this = $(this)
     893      var data  = $this.data('bs.dropdown')
     894
     895      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
     896      if (typeof option == 'string') data[option].call($this)
     897    })
     898  }
     899
     900  var old = $.fn.dropdown
     901
     902  $.fn.dropdown             = Plugin
     903  $.fn.dropdown.Constructor = Dropdown
     904
     905
     906  // DROPDOWN NO CONFLICT
     907  // ====================
     908
     909  $.fn.dropdown.noConflict = function () {
     910    $.fn.dropdown = old
     911    return this
     912  }
     913
     914
     915  // APPLY TO STANDARD DROPDOWN ELEMENTS
     916  // ===================================
     917
     918  $(document)
     919    .on('click.bs.dropdown.data-api', clearMenus)
     920    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
     921    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
     922    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)
     923    .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)
     924
     925}(jQuery);
     926
     927/* ========================================================================
     928 * Bootstrap: modal.js v3.4.1
     929 * https://getbootstrap.com/docs/3.4/javascript/#modals
     930 * ========================================================================
     931 * Copyright 2011-2019 Twitter, Inc.
     932 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     933 * ======================================================================== */
     934
     935
     936+function ($) {
     937  'use strict';
     938
     939  // MODAL CLASS DEFINITION
     940  // ======================
     941
     942  var Modal = function (element, options) {
     943    this.options = options
     944    this.$body = $(document.body)
     945    this.$element = $(element)
     946    this.$dialog = this.$element.find('.modal-dialog')
     947    this.$backdrop = null
     948    this.isShown = null
     949    this.originalBodyPad = null
     950    this.scrollbarWidth = 0
     951    this.ignoreBackdropClick = false
     952    this.fixedContent = '.navbar-fixed-top, .navbar-fixed-bottom'
     953
     954    if (this.options.remote) {
     955      this.$element
     956        .find('.modal-content')
     957        .load(this.options.remote, $.proxy(function () {
     958          this.$element.trigger('loaded.bs.modal')
     959        }, this))
     960    }
     961  }
     962
     963  Modal.VERSION = '3.4.1'
     964
     965  Modal.TRANSITION_DURATION = 300
     966  Modal.BACKDROP_TRANSITION_DURATION = 150
     967
     968  Modal.DEFAULTS = {
    2760969    backdrop: true,
    2761970    keyboard: true,
    2762     focus: true
    2763   };
    2764   const DefaultType$5 = {
    2765     backdrop: '(boolean|string)',
    2766     keyboard: 'boolean',
    2767     focus: 'boolean'
    2768   };
    2769   const EVENT_HIDE$3 = `hide${EVENT_KEY$6}`;
    2770   const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$6}`;
    2771   const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$6}`;
    2772   const EVENT_SHOW$3 = `show${EVENT_KEY$6}`;
    2773   const EVENT_SHOWN$3 = `shown${EVENT_KEY$6}`;
    2774   const EVENT_RESIZE = `resize${EVENT_KEY$6}`;
    2775   const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$6}`;
    2776   const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$6}`;
    2777   const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY$6}`;
    2778   const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$6}`;
    2779   const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
    2780   const CLASS_NAME_OPEN = 'modal-open';
    2781   const CLASS_NAME_FADE$3 = 'fade';
    2782   const CLASS_NAME_SHOW$4 = 'show';
    2783   const CLASS_NAME_STATIC = 'modal-static';
    2784   const OPEN_SELECTOR$1 = '.modal.show';
    2785   const SELECTOR_DIALOG = '.modal-dialog';
    2786   const SELECTOR_MODAL_BODY = '.modal-body';
    2787   const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
    2788   /**
    2789    * ------------------------------------------------------------------------
    2790    * Class Definition
    2791    * ------------------------------------------------------------------------
    2792    */
    2793 
    2794   class Modal extends BaseComponent {
    2795     constructor(element, config) {
    2796       super(element);
    2797       this._config = this._getConfig(config);
    2798       this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
    2799       this._backdrop = this._initializeBackDrop();
    2800       this._focustrap = this._initializeFocusTrap();
    2801       this._isShown = false;
    2802       this._ignoreBackdropClick = false;
    2803       this._isTransitioning = false;
    2804       this._scrollBar = new ScrollBarHelper();
    2805     } // Getters
    2806 
    2807 
    2808     static get Default() {
    2809       return Default$5;
    2810     }
    2811 
    2812     static get NAME() {
    2813       return NAME$6;
    2814     } // Public
    2815 
    2816 
    2817     toggle(relatedTarget) {
    2818       return this._isShown ? this.hide() : this.show(relatedTarget);
    2819     }
    2820 
    2821     show(relatedTarget) {
    2822       if (this._isShown || this._isTransitioning) {
    2823         return;
    2824       }
    2825 
    2826       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
    2827         relatedTarget
    2828       });
    2829 
    2830       if (showEvent.defaultPrevented) {
    2831         return;
    2832       }
    2833 
    2834       this._isShown = true;
    2835 
    2836       if (this._isAnimated()) {
    2837         this._isTransitioning = true;
    2838       }
    2839 
    2840       this._scrollBar.hide();
    2841 
    2842       document.body.classList.add(CLASS_NAME_OPEN);
    2843 
    2844       this._adjustDialog();
    2845 
    2846       this._setEscapeEvent();
    2847 
    2848       this._setResizeEvent();
    2849 
    2850       EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => {
    2851         EventHandler.one(this._element, EVENT_MOUSEUP_DISMISS, event => {
    2852           if (event.target === this._element) {
    2853             this._ignoreBackdropClick = true;
    2854           }
    2855         });
    2856       });
    2857 
    2858       this._showBackdrop(() => this._showElement(relatedTarget));
    2859     }
    2860 
    2861     hide() {
    2862       if (!this._isShown || this._isTransitioning) {
    2863         return;
    2864       }
    2865 
    2866       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
    2867 
    2868       if (hideEvent.defaultPrevented) {
    2869         return;
    2870       }
    2871 
    2872       this._isShown = false;
    2873 
    2874       const isAnimated = this._isAnimated();
    2875 
    2876       if (isAnimated) {
    2877         this._isTransitioning = true;
    2878       }
    2879 
    2880       this._setEscapeEvent();
    2881 
    2882       this._setResizeEvent();
    2883 
    2884       this._focustrap.deactivate();
    2885 
    2886       this._element.classList.remove(CLASS_NAME_SHOW$4);
    2887 
    2888       EventHandler.off(this._element, EVENT_CLICK_DISMISS);
    2889       EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
    2890 
    2891       this._queueCallback(() => this._hideModal(), this._element, isAnimated);
    2892     }
    2893 
    2894     dispose() {
    2895       [window, this._dialog].forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY$6));
    2896 
    2897       this._backdrop.dispose();
    2898 
    2899       this._focustrap.deactivate();
    2900 
    2901       super.dispose();
    2902     }
    2903 
    2904     handleUpdate() {
    2905       this._adjustDialog();
    2906     } // Private
    2907 
    2908 
    2909     _initializeBackDrop() {
    2910       return new Backdrop({
    2911         isVisible: Boolean(this._config.backdrop),
    2912         // 'static' option will be translated to true, and booleans will keep their value
    2913         isAnimated: this._isAnimated()
    2914       });
    2915     }
    2916 
    2917     _initializeFocusTrap() {
    2918       return new FocusTrap({
    2919         trapElement: this._element
    2920       });
    2921     }
    2922 
    2923     _getConfig(config) {
    2924       config = { ...Default$5,
    2925         ...Manipulator.getDataAttributes(this._element),
    2926         ...(typeof config === 'object' ? config : {})
    2927       };
    2928       typeCheckConfig(NAME$6, config, DefaultType$5);
    2929       return config;
    2930     }
    2931 
    2932     _showElement(relatedTarget) {
    2933       const isAnimated = this._isAnimated();
    2934 
    2935       const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
    2936 
    2937       if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
    2938         // Don't move modal's DOM position
    2939         document.body.append(this._element);
    2940       }
    2941 
    2942       this._element.style.display = 'block';
    2943 
    2944       this._element.removeAttribute('aria-hidden');
    2945 
    2946       this._element.setAttribute('aria-modal', true);
    2947 
    2948       this._element.setAttribute('role', 'dialog');
    2949 
    2950       this._element.scrollTop = 0;
    2951 
    2952       if (modalBody) {
    2953         modalBody.scrollTop = 0;
    2954       }
    2955 
    2956       if (isAnimated) {
    2957         reflow(this._element);
    2958       }
    2959 
    2960       this._element.classList.add(CLASS_NAME_SHOW$4);
    2961 
    2962       const transitionComplete = () => {
    2963         if (this._config.focus) {
    2964           this._focustrap.activate();
     971    show: true
     972  }
     973
     974  Modal.prototype.toggle = function (_relatedTarget) {
     975    return this.isShown ? this.hide() : this.show(_relatedTarget)
     976  }
     977
     978  Modal.prototype.show = function (_relatedTarget) {
     979    var that = this
     980    var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
     981
     982    this.$element.trigger(e)
     983
     984    if (this.isShown || e.isDefaultPrevented()) return
     985
     986    this.isShown = true
     987
     988    this.checkScrollbar()
     989    this.setScrollbar()
     990    this.$body.addClass('modal-open')
     991
     992    this.escape()
     993    this.resize()
     994
     995    this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
     996
     997    this.$dialog.on('mousedown.dismiss.bs.modal', function () {
     998      that.$element.one('mouseup.dismiss.bs.modal', function (e) {
     999        if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
     1000      })
     1001    })
     1002
     1003    this.backdrop(function () {
     1004      var transition = $.support.transition && that.$element.hasClass('fade')
     1005
     1006      if (!that.$element.parent().length) {
     1007        that.$element.appendTo(that.$body) // don't move modals dom position
     1008      }
     1009
     1010      that.$element
     1011        .show()
     1012        .scrollTop(0)
     1013
     1014      that.adjustDialog()
     1015
     1016      if (transition) {
     1017        that.$element[0].offsetWidth // force reflow
     1018      }
     1019
     1020      that.$element.addClass('in')
     1021
     1022      that.enforceFocus()
     1023
     1024      var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
     1025
     1026      transition ?
     1027        that.$dialog // wait for modal to slide in
     1028          .one('bsTransitionEnd', function () {
     1029            that.$element.trigger('focus').trigger(e)
     1030          })
     1031          .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
     1032        that.$element.trigger('focus').trigger(e)
     1033    })
     1034  }
     1035
     1036  Modal.prototype.hide = function (e) {
     1037    if (e) e.preventDefault()
     1038
     1039    e = $.Event('hide.bs.modal')
     1040
     1041    this.$element.trigger(e)
     1042
     1043    if (!this.isShown || e.isDefaultPrevented()) return
     1044
     1045    this.isShown = false
     1046
     1047    this.escape()
     1048    this.resize()
     1049
     1050    $(document).off('focusin.bs.modal')
     1051
     1052    this.$element
     1053      .removeClass('in')
     1054      .off('click.dismiss.bs.modal')
     1055      .off('mouseup.dismiss.bs.modal')
     1056
     1057    this.$dialog.off('mousedown.dismiss.bs.modal')
     1058
     1059    $.support.transition && this.$element.hasClass('fade') ?
     1060      this.$element
     1061        .one('bsTransitionEnd', $.proxy(this.hideModal, this))
     1062        .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
     1063      this.hideModal()
     1064  }
     1065
     1066  Modal.prototype.enforceFocus = function () {
     1067    $(document)
     1068      .off('focusin.bs.modal') // guard against infinite focus loop
     1069      .on('focusin.bs.modal', $.proxy(function (e) {
     1070        if (document !== e.target &&
     1071          this.$element[0] !== e.target &&
     1072          !this.$element.has(e.target).length) {
     1073          this.$element.trigger('focus')
    29651074        }
    2966 
    2967         this._isTransitioning = false;
    2968         EventHandler.trigger(this._element, EVENT_SHOWN$3, {
    2969           relatedTarget
    2970         });
    2971       };
    2972 
    2973       this._queueCallback(transitionComplete, this._dialog, isAnimated);
    2974     }
    2975 
    2976     _setEscapeEvent() {
    2977       if (this._isShown) {
    2978         EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
    2979           if (this._config.keyboard && event.key === ESCAPE_KEY$1) {
    2980             event.preventDefault();
    2981             this.hide();
    2982           } else if (!this._config.keyboard && event.key === ESCAPE_KEY$1) {
    2983             this._triggerBackdropTransition();
    2984           }
    2985         });
    2986       } else {
    2987         EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS$1);
    2988       }
    2989     }
    2990 
    2991     _setResizeEvent() {
    2992       if (this._isShown) {
    2993         EventHandler.on(window, EVENT_RESIZE, () => this._adjustDialog());
    2994       } else {
    2995         EventHandler.off(window, EVENT_RESIZE);
    2996       }
    2997     }
    2998 
    2999     _hideModal() {
    3000       this._element.style.display = 'none';
    3001 
    3002       this._element.setAttribute('aria-hidden', true);
    3003 
    3004       this._element.removeAttribute('aria-modal');
    3005 
    3006       this._element.removeAttribute('role');
    3007 
    3008       this._isTransitioning = false;
    3009 
    3010       this._backdrop.hide(() => {
    3011         document.body.classList.remove(CLASS_NAME_OPEN);
    3012 
    3013         this._resetAdjustments();
    3014 
    3015         this._scrollBar.reset();
    3016 
    3017         EventHandler.trigger(this._element, EVENT_HIDDEN$3);
    3018       });
    3019     }
    3020 
    3021     _showBackdrop(callback) {
    3022       EventHandler.on(this._element, EVENT_CLICK_DISMISS, event => {
    3023         if (this._ignoreBackdropClick) {
    3024           this._ignoreBackdropClick = false;
    3025           return;
     1075      }, this))
     1076  }
     1077
     1078  Modal.prototype.escape = function () {
     1079    if (this.isShown && this.options.keyboard) {
     1080      this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
     1081        e.which == 27 && this.hide()
     1082      }, this))
     1083    } else if (!this.isShown) {
     1084      this.$element.off('keydown.dismiss.bs.modal')
     1085    }
     1086  }
     1087
     1088  Modal.prototype.resize = function () {
     1089    if (this.isShown) {
     1090      $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
     1091    } else {
     1092      $(window).off('resize.bs.modal')
     1093    }
     1094  }
     1095
     1096  Modal.prototype.hideModal = function () {
     1097    var that = this
     1098    this.$element.hide()
     1099    this.backdrop(function () {
     1100      that.$body.removeClass('modal-open')
     1101      that.resetAdjustments()
     1102      that.resetScrollbar()
     1103      that.$element.trigger('hidden.bs.modal')
     1104    })
     1105  }
     1106
     1107  Modal.prototype.removeBackdrop = function () {
     1108    this.$backdrop && this.$backdrop.remove()
     1109    this.$backdrop = null
     1110  }
     1111
     1112  Modal.prototype.backdrop = function (callback) {
     1113    var that = this
     1114    var animate = this.$element.hasClass('fade') ? 'fade' : ''
     1115
     1116    if (this.isShown && this.options.backdrop) {
     1117      var doAnimate = $.support.transition && animate
     1118
     1119      this.$backdrop = $(document.createElement('div'))
     1120        .addClass('modal-backdrop ' + animate)
     1121        .appendTo(this.$body)
     1122
     1123      this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
     1124        if (this.ignoreBackdropClick) {
     1125          this.ignoreBackdropClick = false
     1126          return
    30261127        }
    3027 
    3028         if (event.target !== event.currentTarget) {
    3029           return;
    3030         }
    3031 
    3032         if (this._config.backdrop === true) {
    3033           this.hide();
    3034         } else if (this._config.backdrop === 'static') {
    3035           this._triggerBackdropTransition();
    3036         }
    3037       });
    3038 
    3039       this._backdrop.show(callback);
    3040     }
    3041 
    3042     _isAnimated() {
    3043       return this._element.classList.contains(CLASS_NAME_FADE$3);
    3044     }
    3045 
    3046     _triggerBackdropTransition() {
    3047       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
    3048 
    3049       if (hideEvent.defaultPrevented) {
    3050         return;
    3051       }
    3052 
    3053       const {
    3054         classList,
    3055         scrollHeight,
    3056         style
    3057       } = this._element;
    3058       const isModalOverflowing = scrollHeight > document.documentElement.clientHeight; // return if the following background transition hasn't yet completed
    3059 
    3060       if (!isModalOverflowing && style.overflowY === 'hidden' || classList.contains(CLASS_NAME_STATIC)) {
    3061         return;
    3062       }
    3063 
    3064       if (!isModalOverflowing) {
    3065         style.overflowY = 'hidden';
    3066       }
    3067 
    3068       classList.add(CLASS_NAME_STATIC);
    3069 
    3070       this._queueCallback(() => {
    3071         classList.remove(CLASS_NAME_STATIC);
    3072 
    3073         if (!isModalOverflowing) {
    3074           this._queueCallback(() => {
    3075             style.overflowY = '';
    3076           }, this._dialog);
    3077         }
    3078       }, this._dialog);
    3079 
    3080       this._element.focus();
    3081     } // ----------------------------------------------------------------------
    3082     // the following methods are used to handle overflowing modals
    3083     // ----------------------------------------------------------------------
    3084 
    3085 
    3086     _adjustDialog() {
    3087       const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
    3088 
    3089       const scrollbarWidth = this._scrollBar.getWidth();
    3090 
    3091       const isBodyOverflowing = scrollbarWidth > 0;
    3092 
    3093       if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) {
    3094         this._element.style.paddingLeft = `${scrollbarWidth}px`;
    3095       }
    3096 
    3097       if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) {
    3098         this._element.style.paddingRight = `${scrollbarWidth}px`;
    3099       }
    3100     }
    3101 
    3102     _resetAdjustments() {
    3103       this._element.style.paddingLeft = '';
    3104       this._element.style.paddingRight = '';
    3105     } // Static
    3106 
    3107 
    3108     static jQueryInterface(config, relatedTarget) {
    3109       return this.each(function () {
    3110         const data = Modal.getOrCreateInstance(this, config);
    3111 
    3112         if (typeof config !== 'string') {
    3113           return;
    3114         }
    3115 
    3116         if (typeof data[config] === 'undefined') {
    3117           throw new TypeError(`No method named "${config}"`);
    3118         }
    3119 
    3120         data[config](relatedTarget);
    3121       });
    3122     }
    3123 
    3124   }
    3125   /**
    3126    * ------------------------------------------------------------------------
    3127    * Data Api implementation
    3128    * ------------------------------------------------------------------------
    3129    */
    3130 
    3131 
    3132   EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
    3133     const target = getElementFromSelector(this);
    3134 
    3135     if (['A', 'AREA'].includes(this.tagName)) {
    3136       event.preventDefault();
    3137     }
    3138 
    3139     EventHandler.one(target, EVENT_SHOW$3, showEvent => {
    3140       if (showEvent.defaultPrevented) {
    3141         // only register focus restorer if modal will actually get shown
    3142         return;
    3143       }
    3144 
    3145       EventHandler.one(target, EVENT_HIDDEN$3, () => {
    3146         if (isVisible(this)) {
    3147           this.focus();
    3148         }
    3149       });
    3150     }); // avoid conflict when clicking moddal toggler while another one is open
    3151 
    3152     const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
    3153 
    3154     if (allReadyOpen) {
    3155       Modal.getInstance(allReadyOpen).hide();
    3156     }
    3157 
    3158     const data = Modal.getOrCreateInstance(target);
    3159     data.toggle(this);
    3160   });
    3161   enableDismissTrigger(Modal);
    3162   /**
    3163    * ------------------------------------------------------------------------
    3164    * jQuery
    3165    * ------------------------------------------------------------------------
    3166    * add .Modal to jQuery only if jQuery is present
    3167    */
    3168 
    3169   defineJQueryPlugin(Modal);
    3170 
    3171   /**
    3172    * --------------------------------------------------------------------------
    3173    * Bootstrap (v5.1.3): offcanvas.js
    3174    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    3175    * --------------------------------------------------------------------------
    3176    */
    3177   /**
    3178    * ------------------------------------------------------------------------
    3179    * Constants
    3180    * ------------------------------------------------------------------------
    3181    */
    3182 
    3183   const NAME$5 = 'offcanvas';
    3184   const DATA_KEY$5 = 'bs.offcanvas';
    3185   const EVENT_KEY$5 = `.${DATA_KEY$5}`;
    3186   const DATA_API_KEY$2 = '.data-api';
    3187   const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$5}${DATA_API_KEY$2}`;
    3188   const ESCAPE_KEY = 'Escape';
    3189   const Default$4 = {
    3190     backdrop: true,
    3191     keyboard: true,
    3192     scroll: false
    3193   };
    3194   const DefaultType$4 = {
    3195     backdrop: 'boolean',
    3196     keyboard: 'boolean',
    3197     scroll: 'boolean'
    3198   };
    3199   const CLASS_NAME_SHOW$3 = 'show';
    3200   const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
    3201   const OPEN_SELECTOR = '.offcanvas.show';
    3202   const EVENT_SHOW$2 = `show${EVENT_KEY$5}`;
    3203   const EVENT_SHOWN$2 = `shown${EVENT_KEY$5}`;
    3204   const EVENT_HIDE$2 = `hide${EVENT_KEY$5}`;
    3205   const EVENT_HIDDEN$2 = `hidden${EVENT_KEY$5}`;
    3206   const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$5}${DATA_API_KEY$2}`;
    3207   const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$5}`;
    3208   const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
    3209   /**
    3210    * ------------------------------------------------------------------------
    3211    * Class Definition
    3212    * ------------------------------------------------------------------------
    3213    */
    3214 
    3215   class Offcanvas extends BaseComponent {
    3216     constructor(element, config) {
    3217       super(element);
    3218       this._config = this._getConfig(config);
    3219       this._isShown = false;
    3220       this._backdrop = this._initializeBackDrop();
    3221       this._focustrap = this._initializeFocusTrap();
    3222 
    3223       this._addEventListeners();
    3224     } // Getters
    3225 
    3226 
    3227     static get NAME() {
    3228       return NAME$5;
    3229     }
    3230 
    3231     static get Default() {
    3232       return Default$4;
    3233     } // Public
    3234 
    3235 
    3236     toggle(relatedTarget) {
    3237       return this._isShown ? this.hide() : this.show(relatedTarget);
    3238     }
    3239 
    3240     show(relatedTarget) {
    3241       if (this._isShown) {
    3242         return;
    3243       }
    3244 
    3245       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, {
    3246         relatedTarget
    3247       });
    3248 
    3249       if (showEvent.defaultPrevented) {
    3250         return;
    3251       }
    3252 
    3253       this._isShown = true;
    3254       this._element.style.visibility = 'visible';
    3255 
    3256       this._backdrop.show();
    3257 
    3258       if (!this._config.scroll) {
    3259         new ScrollBarHelper().hide();
    3260       }
    3261 
    3262       this._element.removeAttribute('aria-hidden');
    3263 
    3264       this._element.setAttribute('aria-modal', true);
    3265 
    3266       this._element.setAttribute('role', 'dialog');
    3267 
    3268       this._element.classList.add(CLASS_NAME_SHOW$3);
    3269 
    3270       const completeCallBack = () => {
    3271         if (!this._config.scroll) {
    3272           this._focustrap.activate();
    3273         }
    3274 
    3275         EventHandler.trigger(this._element, EVENT_SHOWN$2, {
    3276           relatedTarget
    3277         });
    3278       };
    3279 
    3280       this._queueCallback(completeCallBack, this._element, true);
    3281     }
    3282 
    3283     hide() {
    3284       if (!this._isShown) {
    3285         return;
    3286       }
    3287 
    3288       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2);
    3289 
    3290       if (hideEvent.defaultPrevented) {
    3291         return;
    3292       }
    3293 
    3294       this._focustrap.deactivate();
    3295 
    3296       this._element.blur();
    3297 
    3298       this._isShown = false;
    3299 
    3300       this._element.classList.remove(CLASS_NAME_SHOW$3);
    3301 
    3302       this._backdrop.hide();
    3303 
    3304       const completeCallback = () => {
    3305         this._element.setAttribute('aria-hidden', true);
    3306 
    3307         this._element.removeAttribute('aria-modal');
    3308 
    3309         this._element.removeAttribute('role');
    3310 
    3311         this._element.style.visibility = 'hidden';
    3312 
    3313         if (!this._config.scroll) {
    3314           new ScrollBarHelper().reset();
    3315         }
    3316 
    3317         EventHandler.trigger(this._element, EVENT_HIDDEN$2);
    3318       };
    3319 
    3320       this._queueCallback(completeCallback, this._element, true);
    3321     }
    3322 
    3323     dispose() {
    3324       this._backdrop.dispose();
    3325 
    3326       this._focustrap.deactivate();
    3327 
    3328       super.dispose();
    3329     } // Private
    3330 
    3331 
    3332     _getConfig(config) {
    3333       config = { ...Default$4,
    3334         ...Manipulator.getDataAttributes(this._element),
    3335         ...(typeof config === 'object' ? config : {})
    3336       };
    3337       typeCheckConfig(NAME$5, config, DefaultType$4);
    3338       return config;
    3339     }
    3340 
    3341     _initializeBackDrop() {
    3342       return new Backdrop({
    3343         className: CLASS_NAME_BACKDROP,
    3344         isVisible: this._config.backdrop,
    3345         isAnimated: true,
    3346         rootElement: this._element.parentNode,
    3347         clickCallback: () => this.hide()
    3348       });
    3349     }
    3350 
    3351     _initializeFocusTrap() {
    3352       return new FocusTrap({
    3353         trapElement: this._element
    3354       });
    3355     }
    3356 
    3357     _addEventListeners() {
    3358       EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
    3359         if (this._config.keyboard && event.key === ESCAPE_KEY) {
    3360           this.hide();
    3361         }
    3362       });
    3363     } // Static
    3364 
    3365 
    3366     static jQueryInterface(config) {
    3367       return this.each(function () {
    3368         const data = Offcanvas.getOrCreateInstance(this, config);
    3369 
    3370         if (typeof config !== 'string') {
    3371           return;
    3372         }
    3373 
    3374         if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
    3375           throw new TypeError(`No method named "${config}"`);
    3376         }
    3377 
    3378         data[config](this);
    3379       });
    3380     }
    3381 
    3382   }
    3383   /**
    3384    * ------------------------------------------------------------------------
    3385    * Data Api implementation
    3386    * ------------------------------------------------------------------------
    3387    */
    3388 
    3389 
    3390   EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
    3391     const target = getElementFromSelector(this);
    3392 
    3393     if (['A', 'AREA'].includes(this.tagName)) {
    3394       event.preventDefault();
    3395     }
    3396 
    3397     if (isDisabled(this)) {
    3398       return;
    3399     }
    3400 
    3401     EventHandler.one(target, EVENT_HIDDEN$2, () => {
    3402       // focus on trigger when it is closed
    3403       if (isVisible(this)) {
    3404         this.focus();
    3405       }
    3406     }); // avoid conflict when clicking a toggler of an offcanvas, while another is open
    3407 
    3408     const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
    3409 
    3410     if (allReadyOpen && allReadyOpen !== target) {
    3411       Offcanvas.getInstance(allReadyOpen).hide();
    3412     }
    3413 
    3414     const data = Offcanvas.getOrCreateInstance(target);
    3415     data.toggle(this);
    3416   });
    3417   EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => SelectorEngine.find(OPEN_SELECTOR).forEach(el => Offcanvas.getOrCreateInstance(el).show()));
    3418   enableDismissTrigger(Offcanvas);
    3419   /**
    3420    * ------------------------------------------------------------------------
    3421    * jQuery
    3422    * ------------------------------------------------------------------------
    3423    */
    3424 
    3425   defineJQueryPlugin(Offcanvas);
    3426 
    3427   /**
    3428    * --------------------------------------------------------------------------
    3429    * Bootstrap (v5.1.3): util/sanitizer.js
    3430    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    3431    * --------------------------------------------------------------------------
    3432    */
    3433   const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
    3434   const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
    3435   /**
    3436    * A pattern that recognizes a commonly useful subset of URLs that are safe.
    3437    *
    3438    * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
    3439    */
    3440 
    3441   const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i;
    3442   /**
    3443    * A pattern that matches safe data URLs. Only matches image, video and audio types.
    3444    *
    3445    * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
    3446    */
    3447 
    3448   const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;
    3449 
    3450   const allowedAttribute = (attribute, allowedAttributeList) => {
    3451     const attributeName = attribute.nodeName.toLowerCase();
    3452 
    3453     if (allowedAttributeList.includes(attributeName)) {
    3454       if (uriAttributes.has(attributeName)) {
    3455         return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue));
    3456       }
    3457 
    3458       return true;
    3459     }
    3460 
    3461     const regExp = allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp); // Check if a regular expression validates the attribute.
    3462 
    3463     for (let i = 0, len = regExp.length; i < len; i++) {
    3464       if (regExp[i].test(attributeName)) {
    3465         return true;
    3466       }
    3467     }
    3468 
    3469     return false;
    3470   };
    3471 
    3472   const DefaultAllowlist = {
     1128        if (e.target !== e.currentTarget) return
     1129        this.options.backdrop == 'static'
     1130          ? this.$element[0].focus()
     1131          : this.hide()
     1132      }, this))
     1133
     1134      if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
     1135
     1136      this.$backdrop.addClass('in')
     1137
     1138      if (!callback) return
     1139
     1140      doAnimate ?
     1141        this.$backdrop
     1142          .one('bsTransitionEnd', callback)
     1143          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
     1144        callback()
     1145
     1146    } else if (!this.isShown && this.$backdrop) {
     1147      this.$backdrop.removeClass('in')
     1148
     1149      var callbackRemove = function () {
     1150        that.removeBackdrop()
     1151        callback && callback()
     1152      }
     1153      $.support.transition && this.$element.hasClass('fade') ?
     1154        this.$backdrop
     1155          .one('bsTransitionEnd', callbackRemove)
     1156          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
     1157        callbackRemove()
     1158
     1159    } else if (callback) {
     1160      callback()
     1161    }
     1162  }
     1163
     1164  // these following methods are used to handle overflowing modals
     1165
     1166  Modal.prototype.handleUpdate = function () {
     1167    this.adjustDialog()
     1168  }
     1169
     1170  Modal.prototype.adjustDialog = function () {
     1171    var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight
     1172
     1173    this.$element.css({
     1174      paddingLeft: !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
     1175      paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
     1176    })
     1177  }
     1178
     1179  Modal.prototype.resetAdjustments = function () {
     1180    this.$element.css({
     1181      paddingLeft: '',
     1182      paddingRight: ''
     1183    })
     1184  }
     1185
     1186  Modal.prototype.checkScrollbar = function () {
     1187    var fullWindowWidth = window.innerWidth
     1188    if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
     1189      var documentElementRect = document.documentElement.getBoundingClientRect()
     1190      fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
     1191    }
     1192    this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
     1193    this.scrollbarWidth = this.measureScrollbar()
     1194  }
     1195
     1196  Modal.prototype.setScrollbar = function () {
     1197    var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
     1198    this.originalBodyPad = document.body.style.paddingRight || ''
     1199    var scrollbarWidth = this.scrollbarWidth
     1200    if (this.bodyIsOverflowing) {
     1201      this.$body.css('padding-right', bodyPad + scrollbarWidth)
     1202      $(this.fixedContent).each(function (index, element) {
     1203        var actualPadding = element.style.paddingRight
     1204        var calculatedPadding = $(element).css('padding-right')
     1205        $(element)
     1206          .data('padding-right', actualPadding)
     1207          .css('padding-right', parseFloat(calculatedPadding) + scrollbarWidth + 'px')
     1208      })
     1209    }
     1210  }
     1211
     1212  Modal.prototype.resetScrollbar = function () {
     1213    this.$body.css('padding-right', this.originalBodyPad)
     1214    $(this.fixedContent).each(function (index, element) {
     1215      var padding = $(element).data('padding-right')
     1216      $(element).removeData('padding-right')
     1217      element.style.paddingRight = padding ? padding : ''
     1218    })
     1219  }
     1220
     1221  Modal.prototype.measureScrollbar = function () { // thx walsh
     1222    var scrollDiv = document.createElement('div')
     1223    scrollDiv.className = 'modal-scrollbar-measure'
     1224    this.$body.append(scrollDiv)
     1225    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
     1226    this.$body[0].removeChild(scrollDiv)
     1227    return scrollbarWidth
     1228  }
     1229
     1230
     1231  // MODAL PLUGIN DEFINITION
     1232  // =======================
     1233
     1234  function Plugin(option, _relatedTarget) {
     1235    return this.each(function () {
     1236      var $this = $(this)
     1237      var data = $this.data('bs.modal')
     1238      var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
     1239
     1240      if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
     1241      if (typeof option == 'string') data[option](_relatedTarget)
     1242      else if (options.show) data.show(_relatedTarget)
     1243    })
     1244  }
     1245
     1246  var old = $.fn.modal
     1247
     1248  $.fn.modal = Plugin
     1249  $.fn.modal.Constructor = Modal
     1250
     1251
     1252  // MODAL NO CONFLICT
     1253  // =================
     1254
     1255  $.fn.modal.noConflict = function () {
     1256    $.fn.modal = old
     1257    return this
     1258  }
     1259
     1260
     1261  // MODAL DATA-API
     1262  // ==============
     1263
     1264  $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
     1265    var $this = $(this)
     1266    var href = $this.attr('href')
     1267    var target = $this.attr('data-target') ||
     1268      (href && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
     1269
     1270    var $target = $(document).find(target)
     1271    var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
     1272
     1273    if ($this.is('a')) e.preventDefault()
     1274
     1275    $target.one('show.bs.modal', function (showEvent) {
     1276      if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
     1277      $target.one('hidden.bs.modal', function () {
     1278        $this.is(':visible') && $this.trigger('focus')
     1279      })
     1280    })
     1281    Plugin.call($target, option, this)
     1282  })
     1283
     1284}(jQuery);
     1285
     1286/* ========================================================================
     1287 * Bootstrap: tooltip.js v3.4.1
     1288 * https://getbootstrap.com/docs/3.4/javascript/#tooltip
     1289 * Inspired by the original jQuery.tipsy by Jason Frame
     1290 * ========================================================================
     1291 * Copyright 2011-2019 Twitter, Inc.
     1292 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     1293 * ======================================================================== */
     1294
     1295+function ($) {
     1296  'use strict';
     1297
     1298  var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']
     1299
     1300  var uriAttrs = [
     1301    'background',
     1302    'cite',
     1303    'href',
     1304    'itemtype',
     1305    'longdesc',
     1306    'poster',
     1307    'src',
     1308    'xlink:href'
     1309  ]
     1310
     1311  var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i
     1312
     1313  var DefaultWhitelist = {
    34731314    // Global attributes allowed on any supplied element below.
    34741315    '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
     
    34891330    h6: [],
    34901331    i: [],
    3491     img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
     1332    img: ['src', 'alt', 'title', 'width', 'height'],
    34921333    li: [],
    34931334    ol: [],
     
    35021343    u: [],
    35031344    ul: []
    3504   };
    3505   function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
    3506     if (!unsafeHtml.length) {
    3507       return unsafeHtml;
     1345  }
     1346
     1347  /**
     1348   * A pattern that recognizes a commonly useful subset of URLs that are safe.
     1349   *
     1350   * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
     1351   */
     1352  var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi
     1353
     1354  /**
     1355   * A pattern that matches safe data URLs. Only matches image, video and audio types.
     1356   *
     1357   * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
     1358   */
     1359  var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i
     1360
     1361  function allowedAttribute(attr, allowedAttributeList) {
     1362    var attrName = attr.nodeName.toLowerCase()
     1363
     1364    if ($.inArray(attrName, allowedAttributeList) !== -1) {
     1365      if ($.inArray(attrName, uriAttrs) !== -1) {
     1366        return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN))
     1367      }
     1368
     1369      return true
     1370    }
     1371
     1372    var regExp = $(allowedAttributeList).filter(function (index, value) {
     1373      return value instanceof RegExp
     1374    })
     1375
     1376    // Check if a regular expression validates the attribute.
     1377    for (var i = 0, l = regExp.length; i < l; i++) {
     1378      if (attrName.match(regExp[i])) {
     1379        return true
     1380      }
     1381    }
     1382
     1383    return false
     1384  }
     1385
     1386  function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) {
     1387    if (unsafeHtml.length === 0) {
     1388      return unsafeHtml
    35081389    }
    35091390
    35101391    if (sanitizeFn && typeof sanitizeFn === 'function') {
    3511       return sanitizeFn(unsafeHtml);
    3512     }
    3513 
    3514     const domParser = new window.DOMParser();
    3515     const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
    3516     const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
    3517 
    3518     for (let i = 0, len = elements.length; i < len; i++) {
    3519       const element = elements[i];
    3520       const elementName = element.nodeName.toLowerCase();
    3521 
    3522       if (!Object.keys(allowList).includes(elementName)) {
    3523         element.remove();
    3524         continue;
    3525       }
    3526 
    3527       const attributeList = [].concat(...element.attributes);
    3528       const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
    3529       attributeList.forEach(attribute => {
    3530         if (!allowedAttribute(attribute, allowedAttributes)) {
    3531           element.removeAttribute(attribute.nodeName);
     1392      return sanitizeFn(unsafeHtml)
     1393    }
     1394
     1395    // IE 8 and below don't support createHTMLDocument
     1396    if (!document.implementation || !document.implementation.createHTMLDocument) {
     1397      return unsafeHtml
     1398    }
     1399
     1400    var createdDocument = document.implementation.createHTMLDocument('sanitization')
     1401    createdDocument.body.innerHTML = unsafeHtml
     1402
     1403    var whitelistKeys = $.map(whiteList, function (el, i) { return i })
     1404    var elements = $(createdDocument.body).find('*')
     1405
     1406    for (var i = 0, len = elements.length; i < len; i++) {
     1407      var el = elements[i]
     1408      var elName = el.nodeName.toLowerCase()
     1409
     1410      if ($.inArray(elName, whitelistKeys) === -1) {
     1411        el.parentNode.removeChild(el)
     1412
     1413        continue
     1414      }
     1415
     1416      var attributeList = $.map(el.attributes, function (el) { return el })
     1417      var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || [])
     1418
     1419      for (var j = 0, len2 = attributeList.length; j < len2; j++) {
     1420        if (!allowedAttribute(attributeList[j], whitelistedAttributes)) {
     1421          el.removeAttribute(attributeList[j].nodeName)
    35321422        }
    3533       });
    3534     }
    3535 
    3536     return createdDocument.body.innerHTML;
    3537   }
    3538 
    3539   /**
    3540    * --------------------------------------------------------------------------
    3541    * Bootstrap (v5.1.3): tooltip.js
    3542    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    3543    * --------------------------------------------------------------------------
    3544    */
    3545   /**
    3546    * ------------------------------------------------------------------------
    3547    * Constants
    3548    * ------------------------------------------------------------------------
    3549    */
    3550 
    3551   const NAME$4 = 'tooltip';
    3552   const DATA_KEY$4 = 'bs.tooltip';
    3553   const EVENT_KEY$4 = `.${DATA_KEY$4}`;
    3554   const CLASS_PREFIX$1 = 'bs-tooltip';
    3555   const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
    3556   const DefaultType$3 = {
    3557     animation: 'boolean',
    3558     template: 'string',
    3559     title: '(string|element|function)',
    3560     trigger: 'string',
    3561     delay: '(number|object)',
    3562     html: 'boolean',
    3563     selector: '(string|boolean)',
    3564     placement: '(string|function)',
    3565     offset: '(array|string|function)',
    3566     container: '(string|element|boolean)',
    3567     fallbackPlacements: 'array',
    3568     boundary: '(string|element)',
    3569     customClass: '(string|function)',
    3570     sanitize: 'boolean',
    3571     sanitizeFn: '(null|function)',
    3572     allowList: 'object',
    3573     popperConfig: '(null|object|function)'
    3574   };
    3575   const AttachmentMap = {
    3576     AUTO: 'auto',
    3577     TOP: 'top',
    3578     RIGHT: isRTL() ? 'left' : 'right',
    3579     BOTTOM: 'bottom',
    3580     LEFT: isRTL() ? 'right' : 'left'
    3581   };
    3582   const Default$3 = {
     1423      }
     1424    }
     1425
     1426    return createdDocument.body.innerHTML
     1427  }
     1428
     1429  // TOOLTIP PUBLIC CLASS DEFINITION
     1430  // ===============================
     1431
     1432  var Tooltip = function (element, options) {
     1433    this.type       = null
     1434    this.options    = null
     1435    this.enabled    = null
     1436    this.timeout    = null
     1437    this.hoverState = null
     1438    this.$element   = null
     1439    this.inState    = null
     1440
     1441    this.init('tooltip', element, options)
     1442  }
     1443
     1444  Tooltip.VERSION  = '3.4.1'
     1445
     1446  Tooltip.TRANSITION_DURATION = 150
     1447
     1448  Tooltip.DEFAULTS = {
    35831449    animation: true,
    3584     template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
     1450    placement: 'top',
     1451    selector: false,
     1452    template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
    35851453    trigger: 'hover focus',
    35861454    title: '',
    35871455    delay: 0,
    35881456    html: false,
    3589     selector: false,
    3590     placement: 'top',
    3591     offset: [0, 0],
    35921457    container: false,
    3593     fallbackPlacements: ['top', 'right', 'bottom', 'left'],
    3594     boundary: 'clippingParents',
    3595     customClass: '',
    3596     sanitize: true,
    3597     sanitizeFn: null,
    3598     allowList: DefaultAllowlist,
    3599     popperConfig: null
    3600   };
    3601   const Event$2 = {
    3602     HIDE: `hide${EVENT_KEY$4}`,
    3603     HIDDEN: `hidden${EVENT_KEY$4}`,
    3604     SHOW: `show${EVENT_KEY$4}`,
    3605     SHOWN: `shown${EVENT_KEY$4}`,
    3606     INSERTED: `inserted${EVENT_KEY$4}`,
    3607     CLICK: `click${EVENT_KEY$4}`,
    3608     FOCUSIN: `focusin${EVENT_KEY$4}`,
    3609     FOCUSOUT: `focusout${EVENT_KEY$4}`,
    3610     MOUSEENTER: `mouseenter${EVENT_KEY$4}`,
    3611     MOUSELEAVE: `mouseleave${EVENT_KEY$4}`
    3612   };
    3613   const CLASS_NAME_FADE$2 = 'fade';
    3614   const CLASS_NAME_MODAL = 'modal';
    3615   const CLASS_NAME_SHOW$2 = 'show';
    3616   const HOVER_STATE_SHOW = 'show';
    3617   const HOVER_STATE_OUT = 'out';
    3618   const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
    3619   const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
    3620   const EVENT_MODAL_HIDE = 'hide.bs.modal';
    3621   const TRIGGER_HOVER = 'hover';
    3622   const TRIGGER_FOCUS = 'focus';
    3623   const TRIGGER_CLICK = 'click';
    3624   const TRIGGER_MANUAL = 'manual';
    3625   /**
    3626    * ------------------------------------------------------------------------
    3627    * Class Definition
    3628    * ------------------------------------------------------------------------
    3629    */
    3630 
    3631   class Tooltip extends BaseComponent {
    3632     constructor(element, config) {
    3633       if (typeof Popper__namespace === 'undefined') {
    3634         throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
    3635       }
    3636 
    3637       super(element); // private
    3638 
    3639       this._isEnabled = true;
    3640       this._timeout = 0;
    3641       this._hoverState = '';
    3642       this._activeTrigger = {};
    3643       this._popper = null; // Protected
    3644 
    3645       this._config = this._getConfig(config);
    3646       this.tip = null;
    3647 
    3648       this._setListeners();
    3649     } // Getters
    3650 
    3651 
    3652     static get Default() {
    3653       return Default$3;
    3654     }
    3655 
    3656     static get NAME() {
    3657       return NAME$4;
    3658     }
    3659 
    3660     static get Event() {
    3661       return Event$2;
    3662     }
    3663 
    3664     static get DefaultType() {
    3665       return DefaultType$3;
    3666     } // Public
    3667 
    3668 
    3669     enable() {
    3670       this._isEnabled = true;
    3671     }
    3672 
    3673     disable() {
    3674       this._isEnabled = false;
    3675     }
    3676 
    3677     toggleEnabled() {
    3678       this._isEnabled = !this._isEnabled;
    3679     }
    3680 
    3681     toggle(event) {
    3682       if (!this._isEnabled) {
    3683         return;
    3684       }
    3685 
    3686       if (event) {
    3687         const context = this._initializeOnDelegatedTarget(event);
    3688 
    3689         context._activeTrigger.click = !context._activeTrigger.click;
    3690 
    3691         if (context._isWithActiveTrigger()) {
    3692           context._enter(null, context);
    3693         } else {
    3694           context._leave(null, context);
    3695         }
    3696       } else {
    3697         if (this.getTipElement().classList.contains(CLASS_NAME_SHOW$2)) {
    3698           this._leave(null, this);
    3699 
    3700           return;
    3701         }
    3702 
    3703         this._enter(null, this);
    3704       }
    3705     }
    3706 
    3707     dispose() {
    3708       clearTimeout(this._timeout);
    3709       EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
    3710 
    3711       if (this.tip) {
    3712         this.tip.remove();
    3713       }
    3714 
    3715       this._disposePopper();
    3716 
    3717       super.dispose();
    3718     }
    3719 
    3720     show() {
    3721       if (this._element.style.display === 'none') {
    3722         throw new Error('Please use show on visible elements');
    3723       }
    3724 
    3725       if (!(this.isWithContent() && this._isEnabled)) {
    3726         return;
    3727       }
    3728 
    3729       const showEvent = EventHandler.trigger(this._element, this.constructor.Event.SHOW);
    3730       const shadowRoot = findShadowRoot(this._element);
    3731       const isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element);
    3732 
    3733       if (showEvent.defaultPrevented || !isInTheDom) {
    3734         return;
    3735       } // A trick to recreate a tooltip in case a new title is given by using the NOT documented `data-bs-original-title`
    3736       // This will be removed later in favor of a `setContent` method
    3737 
    3738 
    3739       if (this.constructor.NAME === 'tooltip' && this.tip && this.getTitle() !== this.tip.querySelector(SELECTOR_TOOLTIP_INNER).innerHTML) {
    3740         this._disposePopper();
    3741 
    3742         this.tip.remove();
    3743         this.tip = null;
    3744       }
    3745 
    3746       const tip = this.getTipElement();
    3747       const tipId = getUID(this.constructor.NAME);
    3748       tip.setAttribute('id', tipId);
    3749 
    3750       this._element.setAttribute('aria-describedby', tipId);
    3751 
    3752       if (this._config.animation) {
    3753         tip.classList.add(CLASS_NAME_FADE$2);
    3754       }
    3755 
    3756       const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement;
    3757 
    3758       const attachment = this._getAttachment(placement);
    3759 
    3760       this._addAttachmentClass(attachment);
    3761 
    3762       const {
    3763         container
    3764       } = this._config;
    3765       Data.set(tip, this.constructor.DATA_KEY, this);
    3766 
    3767       if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
    3768         container.append(tip);
    3769         EventHandler.trigger(this._element, this.constructor.Event.INSERTED);
    3770       }
    3771 
    3772       if (this._popper) {
    3773         this._popper.update();
    3774       } else {
    3775         this._popper = Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment));
    3776       }
    3777 
    3778       tip.classList.add(CLASS_NAME_SHOW$2);
    3779 
    3780       const customClass = this._resolvePossibleFunction(this._config.customClass);
    3781 
    3782       if (customClass) {
    3783         tip.classList.add(...customClass.split(' '));
    3784       } // If this is a touch-enabled device we add extra
    3785       // empty mouseover listeners to the body's immediate children;
    3786       // only needed because of broken event delegation on iOS
    3787       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
    3788 
    3789 
    3790       if ('ontouchstart' in document.documentElement) {
    3791         [].concat(...document.body.children).forEach(element => {
    3792           EventHandler.on(element, 'mouseover', noop);
    3793         });
    3794       }
    3795 
    3796       const complete = () => {
    3797         const prevHoverState = this._hoverState;
    3798         this._hoverState = null;
    3799         EventHandler.trigger(this._element, this.constructor.Event.SHOWN);
    3800 
    3801         if (prevHoverState === HOVER_STATE_OUT) {
    3802           this._leave(null, this);
    3803         }
    3804       };
    3805 
    3806       const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
    3807 
    3808       this._queueCallback(complete, this.tip, isAnimated);
    3809     }
    3810 
    3811     hide() {
    3812       if (!this._popper) {
    3813         return;
    3814       }
    3815 
    3816       const tip = this.getTipElement();
    3817 
    3818       const complete = () => {
    3819         if (this._isWithActiveTrigger()) {
    3820           return;
    3821         }
    3822 
    3823         if (this._hoverState !== HOVER_STATE_SHOW) {
    3824           tip.remove();
    3825         }
    3826 
    3827         this._cleanTipClass();
    3828 
    3829         this._element.removeAttribute('aria-describedby');
    3830 
    3831         EventHandler.trigger(this._element, this.constructor.Event.HIDDEN);
    3832 
    3833         this._disposePopper();
    3834       };
    3835 
    3836       const hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE);
    3837 
    3838       if (hideEvent.defaultPrevented) {
    3839         return;
    3840       }
    3841 
    3842       tip.classList.remove(CLASS_NAME_SHOW$2); // If this is a touch-enabled device we remove the extra
    3843       // empty mouseover listeners we added for iOS support
    3844 
    3845       if ('ontouchstart' in document.documentElement) {
    3846         [].concat(...document.body.children).forEach(element => EventHandler.off(element, 'mouseover', noop));
    3847       }
    3848 
    3849       this._activeTrigger[TRIGGER_CLICK] = false;
    3850       this._activeTrigger[TRIGGER_FOCUS] = false;
    3851       this._activeTrigger[TRIGGER_HOVER] = false;
    3852       const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
    3853 
    3854       this._queueCallback(complete, this.tip, isAnimated);
    3855 
    3856       this._hoverState = '';
    3857     }
    3858 
    3859     update() {
    3860       if (this._popper !== null) {
    3861         this._popper.update();
    3862       }
    3863     } // Protected
    3864 
    3865 
    3866     isWithContent() {
    3867       return Boolean(this.getTitle());
    3868     }
    3869 
    3870     getTipElement() {
    3871       if (this.tip) {
    3872         return this.tip;
    3873       }
    3874 
    3875       const element = document.createElement('div');
    3876       element.innerHTML = this._config.template;
    3877       const tip = element.children[0];
    3878       this.setContent(tip);
    3879       tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
    3880       this.tip = tip;
    3881       return this.tip;
    3882     }
    3883 
    3884     setContent(tip) {
    3885       this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TOOLTIP_INNER);
    3886     }
    3887 
    3888     _sanitizeAndSetContent(template, content, selector) {
    3889       const templateElement = SelectorEngine.findOne(selector, template);
    3890 
    3891       if (!content && templateElement) {
    3892         templateElement.remove();
    3893         return;
    3894       } // we use append for html objects to maintain js events
    3895 
    3896 
    3897       this.setElementContent(templateElement, content);
    3898     }
    3899 
    3900     setElementContent(element, content) {
    3901       if (element === null) {
    3902         return;
    3903       }
    3904 
    3905       if (isElement(content)) {
    3906         content = getElement(content); // content is a DOM node or a jQuery
    3907 
    3908         if (this._config.html) {
    3909           if (content.parentNode !== element) {
    3910             element.innerHTML = '';
    3911             element.append(content);
    3912           }
    3913         } else {
    3914           element.textContent = content.textContent;
    3915         }
    3916 
    3917         return;
    3918       }
    3919 
    3920       if (this._config.html) {
    3921         if (this._config.sanitize) {
    3922           content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn);
    3923         }
    3924 
    3925         element.innerHTML = content;
    3926       } else {
    3927         element.textContent = content;
    3928       }
    3929     }
    3930 
    3931     getTitle() {
    3932       const title = this._element.getAttribute('data-bs-original-title') || this._config.title;
    3933 
    3934       return this._resolvePossibleFunction(title);
    3935     }
    3936 
    3937     updateAttachment(attachment) {
    3938       if (attachment === 'right') {
    3939         return 'end';
    3940       }
    3941 
    3942       if (attachment === 'left') {
    3943         return 'start';
    3944       }
    3945 
    3946       return attachment;
    3947     } // Private
    3948 
    3949 
    3950     _initializeOnDelegatedTarget(event, context) {
    3951       return context || this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
    3952     }
    3953 
    3954     _getOffset() {
    3955       const {
    3956         offset
    3957       } = this._config;
    3958 
    3959       if (typeof offset === 'string') {
    3960         return offset.split(',').map(val => Number.parseInt(val, 10));
    3961       }
    3962 
    3963       if (typeof offset === 'function') {
    3964         return popperData => offset(popperData, this._element);
    3965       }
    3966 
    3967       return offset;
    3968     }
    3969 
    3970     _resolvePossibleFunction(content) {
    3971       return typeof content === 'function' ? content.call(this._element) : content;
    3972     }
    3973 
    3974     _getPopperConfig(attachment) {
    3975       const defaultBsPopperConfig = {
    3976         placement: attachment,
    3977         modifiers: [{
    3978           name: 'flip',
    3979           options: {
    3980             fallbackPlacements: this._config.fallbackPlacements
    3981           }
    3982         }, {
    3983           name: 'offset',
    3984           options: {
    3985             offset: this._getOffset()
    3986           }
    3987         }, {
    3988           name: 'preventOverflow',
    3989           options: {
    3990             boundary: this._config.boundary
    3991           }
    3992         }, {
    3993           name: 'arrow',
    3994           options: {
    3995             element: `.${this.constructor.NAME}-arrow`
    3996           }
    3997         }, {
    3998           name: 'onChange',
    3999           enabled: true,
    4000           phase: 'afterWrite',
    4001           fn: data => this._handlePopperPlacementChange(data)
    4002         }],
    4003         onFirstUpdate: data => {
    4004           if (data.options.placement !== data.placement) {
    4005             this._handlePopperPlacementChange(data);
    4006           }
    4007         }
    4008       };
    4009       return { ...defaultBsPopperConfig,
    4010         ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
    4011       };
    4012     }
    4013 
    4014     _addAttachmentClass(attachment) {
    4015       this.getTipElement().classList.add(`${this._getBasicClassPrefix()}-${this.updateAttachment(attachment)}`);
    4016     }
    4017 
    4018     _getAttachment(placement) {
    4019       return AttachmentMap[placement.toUpperCase()];
    4020     }
    4021 
    4022     _setListeners() {
    4023       const triggers = this._config.trigger.split(' ');
    4024 
    4025       triggers.forEach(trigger => {
    4026         if (trigger === 'click') {
    4027           EventHandler.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event));
    4028         } else if (trigger !== TRIGGER_MANUAL) {
    4029           const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN;
    4030           const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT;
    4031           EventHandler.on(this._element, eventIn, this._config.selector, event => this._enter(event));
    4032           EventHandler.on(this._element, eventOut, this._config.selector, event => this._leave(event));
    4033         }
    4034       });
    4035 
    4036       this._hideModalHandler = () => {
    4037         if (this._element) {
    4038           this.hide();
    4039         }
    4040       };
    4041 
    4042       EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
    4043 
    4044       if (this._config.selector) {
    4045         this._config = { ...this._config,
    4046           trigger: 'manual',
    4047           selector: ''
    4048         };
    4049       } else {
    4050         this._fixTitle();
    4051       }
    4052     }
    4053 
    4054     _fixTitle() {
    4055       const title = this._element.getAttribute('title');
    4056 
    4057       const originalTitleType = typeof this._element.getAttribute('data-bs-original-title');
    4058 
    4059       if (title || originalTitleType !== 'string') {
    4060         this._element.setAttribute('data-bs-original-title', title || '');
    4061 
    4062         if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) {
    4063           this._element.setAttribute('aria-label', title);
    4064         }
    4065 
    4066         this._element.setAttribute('title', '');
    4067       }
    4068     }
    4069 
    4070     _enter(event, context) {
    4071       context = this._initializeOnDelegatedTarget(event, context);
    4072 
    4073       if (event) {
    4074         context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
    4075       }
    4076 
    4077       if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$2) || context._hoverState === HOVER_STATE_SHOW) {
    4078         context._hoverState = HOVER_STATE_SHOW;
    4079         return;
    4080       }
    4081 
    4082       clearTimeout(context._timeout);
    4083       context._hoverState = HOVER_STATE_SHOW;
    4084 
    4085       if (!context._config.delay || !context._config.delay.show) {
    4086         context.show();
    4087         return;
    4088       }
    4089 
    4090       context._timeout = setTimeout(() => {
    4091         if (context._hoverState === HOVER_STATE_SHOW) {
    4092           context.show();
    4093         }
    4094       }, context._config.delay.show);
    4095     }
    4096 
    4097     _leave(event, context) {
    4098       context = this._initializeOnDelegatedTarget(event, context);
    4099 
    4100       if (event) {
    4101         context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
    4102       }
    4103 
    4104       if (context._isWithActiveTrigger()) {
    4105         return;
    4106       }
    4107 
    4108       clearTimeout(context._timeout);
    4109       context._hoverState = HOVER_STATE_OUT;
    4110 
    4111       if (!context._config.delay || !context._config.delay.hide) {
    4112         context.hide();
    4113         return;
    4114       }
    4115 
    4116       context._timeout = setTimeout(() => {
    4117         if (context._hoverState === HOVER_STATE_OUT) {
    4118           context.hide();
    4119         }
    4120       }, context._config.delay.hide);
    4121     }
    4122 
    4123     _isWithActiveTrigger() {
    4124       for (const trigger in this._activeTrigger) {
    4125         if (this._activeTrigger[trigger]) {
    4126           return true;
    4127         }
    4128       }
    4129 
    4130       return false;
    4131     }
    4132 
    4133     _getConfig(config) {
    4134       const dataAttributes = Manipulator.getDataAttributes(this._element);
    4135       Object.keys(dataAttributes).forEach(dataAttr => {
    4136         if (DISALLOWED_ATTRIBUTES.has(dataAttr)) {
    4137           delete dataAttributes[dataAttr];
    4138         }
    4139       });
    4140       config = { ...this.constructor.Default,
    4141         ...dataAttributes,
    4142         ...(typeof config === 'object' && config ? config : {})
    4143       };
    4144       config.container = config.container === false ? document.body : getElement(config.container);
    4145 
    4146       if (typeof config.delay === 'number') {
    4147         config.delay = {
    4148           show: config.delay,
    4149           hide: config.delay
    4150         };
    4151       }
    4152 
    4153       if (typeof config.title === 'number') {
    4154         config.title = config.title.toString();
    4155       }
    4156 
    4157       if (typeof config.content === 'number') {
    4158         config.content = config.content.toString();
    4159       }
    4160 
    4161       typeCheckConfig(NAME$4, config, this.constructor.DefaultType);
    4162 
    4163       if (config.sanitize) {
    4164         config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn);
    4165       }
    4166 
    4167       return config;
    4168     }
    4169 
    4170     _getDelegateConfig() {
    4171       const config = {};
    4172 
    4173       for (const key in this._config) {
    4174         if (this.constructor.Default[key] !== this._config[key]) {
    4175           config[key] = this._config[key];
    4176         }
    4177       } // In the future can be replaced with:
    4178       // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
    4179       // `Object.fromEntries(keysWithDifferentValues)`
    4180 
    4181 
    4182       return config;
    4183     }
    4184 
    4185     _cleanTipClass() {
    4186       const tip = this.getTipElement();
    4187       const basicClassPrefixRegex = new RegExp(`(^|\\s)${this._getBasicClassPrefix()}\\S+`, 'g');
    4188       const tabClass = tip.getAttribute('class').match(basicClassPrefixRegex);
    4189 
    4190       if (tabClass !== null && tabClass.length > 0) {
    4191         tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass));
    4192       }
    4193     }
    4194 
    4195     _getBasicClassPrefix() {
    4196       return CLASS_PREFIX$1;
    4197     }
    4198 
    4199     _handlePopperPlacementChange(popperData) {
    4200       const {
    4201         state
    4202       } = popperData;
    4203 
    4204       if (!state) {
    4205         return;
    4206       }
    4207 
    4208       this.tip = state.elements.popper;
    4209 
    4210       this._cleanTipClass();
    4211 
    4212       this._addAttachmentClass(this._getAttachment(state.placement));
    4213     }
    4214 
    4215     _disposePopper() {
    4216       if (this._popper) {
    4217         this._popper.destroy();
    4218 
    4219         this._popper = null;
    4220       }
    4221     } // Static
    4222 
    4223 
    4224     static jQueryInterface(config) {
    4225       return this.each(function () {
    4226         const data = Tooltip.getOrCreateInstance(this, config);
    4227 
    4228         if (typeof config === 'string') {
    4229           if (typeof data[config] === 'undefined') {
    4230             throw new TypeError(`No method named "${config}"`);
    4231           }
    4232 
    4233           data[config]();
    4234         }
    4235       });
    4236     }
    4237 
    4238   }
    4239   /**
    4240    * ------------------------------------------------------------------------
    4241    * jQuery
    4242    * ------------------------------------------------------------------------
    4243    * add .Tooltip to jQuery only if jQuery is present
    4244    */
    4245 
    4246 
    4247   defineJQueryPlugin(Tooltip);
    4248 
    4249   /**
    4250    * --------------------------------------------------------------------------
    4251    * Bootstrap (v5.1.3): popover.js
    4252    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    4253    * --------------------------------------------------------------------------
    4254    */
    4255   /**
    4256    * ------------------------------------------------------------------------
    4257    * Constants
    4258    * ------------------------------------------------------------------------
    4259    */
    4260 
    4261   const NAME$3 = 'popover';
    4262   const DATA_KEY$3 = 'bs.popover';
    4263   const EVENT_KEY$3 = `.${DATA_KEY$3}`;
    4264   const CLASS_PREFIX = 'bs-popover';
    4265   const Default$2 = { ...Tooltip.Default,
     1458    viewport: {
     1459      selector: 'body',
     1460      padding: 0
     1461    },
     1462    sanitize : true,
     1463    sanitizeFn : null,
     1464    whiteList : DefaultWhitelist
     1465  }
     1466
     1467  Tooltip.prototype.init = function (type, element, options) {
     1468    this.enabled   = true
     1469    this.type      = type
     1470    this.$element  = $(element)
     1471    this.options   = this.getOptions(options)
     1472    this.$viewport = this.options.viewport && $(document).find($.isFunction(this.options.viewport) ? this.options.viewport.call(this, this.$element) : (this.options.viewport.selector || this.options.viewport))
     1473    this.inState   = { click: false, hover: false, focus: false }
     1474
     1475    if (this.$element[0] instanceof document.constructor && !this.options.selector) {
     1476      throw new Error('`selector` option must be specified when initializing ' + this.type + ' on the window.document object!')
     1477    }
     1478
     1479    var triggers = this.options.trigger.split(' ')
     1480
     1481    for (var i = triggers.length; i--;) {
     1482      var trigger = triggers[i]
     1483
     1484      if (trigger == 'click') {
     1485        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
     1486      } else if (trigger != 'manual') {
     1487        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
     1488        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
     1489
     1490        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
     1491        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
     1492      }
     1493    }
     1494
     1495    this.options.selector ?
     1496      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
     1497      this.fixTitle()
     1498  }
     1499
     1500  Tooltip.prototype.getDefaults = function () {
     1501    return Tooltip.DEFAULTS
     1502  }
     1503
     1504  Tooltip.prototype.getOptions = function (options) {
     1505    var dataAttributes = this.$element.data()
     1506
     1507    for (var dataAttr in dataAttributes) {
     1508      if (dataAttributes.hasOwnProperty(dataAttr) && $.inArray(dataAttr, DISALLOWED_ATTRIBUTES) !== -1) {
     1509        delete dataAttributes[dataAttr]
     1510      }
     1511    }
     1512
     1513    options = $.extend({}, this.getDefaults(), dataAttributes, options)
     1514
     1515    if (options.delay && typeof options.delay == 'number') {
     1516      options.delay = {
     1517        show: options.delay,
     1518        hide: options.delay
     1519      }
     1520    }
     1521
     1522    if (options.sanitize) {
     1523      options.template = sanitizeHtml(options.template, options.whiteList, options.sanitizeFn)
     1524    }
     1525
     1526    return options
     1527  }
     1528
     1529  Tooltip.prototype.getDelegateOptions = function () {
     1530    var options  = {}
     1531    var defaults = this.getDefaults()
     1532
     1533    this._options && $.each(this._options, function (key, value) {
     1534      if (defaults[key] != value) options[key] = value
     1535    })
     1536
     1537    return options
     1538  }
     1539
     1540  Tooltip.prototype.enter = function (obj) {
     1541    var self = obj instanceof this.constructor ?
     1542      obj : $(obj.currentTarget).data('bs.' + this.type)
     1543
     1544    if (!self) {
     1545      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
     1546      $(obj.currentTarget).data('bs.' + this.type, self)
     1547    }
     1548
     1549    if (obj instanceof $.Event) {
     1550      self.inState[obj.type == 'focusin' ? 'focus' : 'hover'] = true
     1551    }
     1552
     1553    if (self.tip().hasClass('in') || self.hoverState == 'in') {
     1554      self.hoverState = 'in'
     1555      return
     1556    }
     1557
     1558    clearTimeout(self.timeout)
     1559
     1560    self.hoverState = 'in'
     1561
     1562    if (!self.options.delay || !self.options.delay.show) return self.show()
     1563
     1564    self.timeout = setTimeout(function () {
     1565      if (self.hoverState == 'in') self.show()
     1566    }, self.options.delay.show)
     1567  }
     1568
     1569  Tooltip.prototype.isInStateTrue = function () {
     1570    for (var key in this.inState) {
     1571      if (this.inState[key]) return true
     1572    }
     1573
     1574    return false
     1575  }
     1576
     1577  Tooltip.prototype.leave = function (obj) {
     1578    var self = obj instanceof this.constructor ?
     1579      obj : $(obj.currentTarget).data('bs.' + this.type)
     1580
     1581    if (!self) {
     1582      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
     1583      $(obj.currentTarget).data('bs.' + this.type, self)
     1584    }
     1585
     1586    if (obj instanceof $.Event) {
     1587      self.inState[obj.type == 'focusout' ? 'focus' : 'hover'] = false
     1588    }
     1589
     1590    if (self.isInStateTrue()) return
     1591
     1592    clearTimeout(self.timeout)
     1593
     1594    self.hoverState = 'out'
     1595
     1596    if (!self.options.delay || !self.options.delay.hide) return self.hide()
     1597
     1598    self.timeout = setTimeout(function () {
     1599      if (self.hoverState == 'out') self.hide()
     1600    }, self.options.delay.hide)
     1601  }
     1602
     1603  Tooltip.prototype.show = function () {
     1604    var e = $.Event('show.bs.' + this.type)
     1605
     1606    if (this.hasContent() && this.enabled) {
     1607      this.$element.trigger(e)
     1608
     1609      var inDom = $.contains(this.$element[0].ownerDocument.documentElement, this.$element[0])
     1610      if (e.isDefaultPrevented() || !inDom) return
     1611      var that = this
     1612
     1613      var $tip = this.tip()
     1614
     1615      var tipId = this.getUID(this.type)
     1616
     1617      this.setContent()
     1618      $tip.attr('id', tipId)
     1619      this.$element.attr('aria-describedby', tipId)
     1620
     1621      if (this.options.animation) $tip.addClass('fade')
     1622
     1623      var placement = typeof this.options.placement == 'function' ?
     1624        this.options.placement.call(this, $tip[0], this.$element[0]) :
     1625        this.options.placement
     1626
     1627      var autoToken = /\s?auto?\s?/i
     1628      var autoPlace = autoToken.test(placement)
     1629      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
     1630
     1631      $tip
     1632        .detach()
     1633        .css({ top: 0, left: 0, display: 'block' })
     1634        .addClass(placement)
     1635        .data('bs.' + this.type, this)
     1636
     1637      this.options.container ? $tip.appendTo($(document).find(this.options.container)) : $tip.insertAfter(this.$element)
     1638      this.$element.trigger('inserted.bs.' + this.type)
     1639
     1640      var pos          = this.getPosition()
     1641      var actualWidth  = $tip[0].offsetWidth
     1642      var actualHeight = $tip[0].offsetHeight
     1643
     1644      if (autoPlace) {
     1645        var orgPlacement = placement
     1646        var viewportDim = this.getPosition(this.$viewport)
     1647
     1648        placement = placement == 'bottom' && pos.bottom + actualHeight > viewportDim.bottom ? 'top'    :
     1649                    placement == 'top'    && pos.top    - actualHeight < viewportDim.top    ? 'bottom' :
     1650                    placement == 'right'  && pos.right  + actualWidth  > viewportDim.width  ? 'left'   :
     1651                    placement == 'left'   && pos.left   - actualWidth  < viewportDim.left   ? 'right'  :
     1652                    placement
     1653
     1654        $tip
     1655          .removeClass(orgPlacement)
     1656          .addClass(placement)
     1657      }
     1658
     1659      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
     1660
     1661      this.applyPlacement(calculatedOffset, placement)
     1662
     1663      var complete = function () {
     1664        var prevHoverState = that.hoverState
     1665        that.$element.trigger('shown.bs.' + that.type)
     1666        that.hoverState = null
     1667
     1668        if (prevHoverState == 'out') that.leave(that)
     1669      }
     1670
     1671      $.support.transition && this.$tip.hasClass('fade') ?
     1672        $tip
     1673          .one('bsTransitionEnd', complete)
     1674          .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
     1675        complete()
     1676    }
     1677  }
     1678
     1679  Tooltip.prototype.applyPlacement = function (offset, placement) {
     1680    var $tip   = this.tip()
     1681    var width  = $tip[0].offsetWidth
     1682    var height = $tip[0].offsetHeight
     1683
     1684    // manually read margins because getBoundingClientRect includes difference
     1685    var marginTop = parseInt($tip.css('margin-top'), 10)
     1686    var marginLeft = parseInt($tip.css('margin-left'), 10)
     1687
     1688    // we must check for NaN for ie 8/9
     1689    if (isNaN(marginTop))  marginTop  = 0
     1690    if (isNaN(marginLeft)) marginLeft = 0
     1691
     1692    offset.top  += marginTop
     1693    offset.left += marginLeft
     1694
     1695    // $.fn.offset doesn't round pixel values
     1696    // so we use setOffset directly with our own function B-0
     1697    $.offset.setOffset($tip[0], $.extend({
     1698      using: function (props) {
     1699        $tip.css({
     1700          top: Math.round(props.top),
     1701          left: Math.round(props.left)
     1702        })
     1703      }
     1704    }, offset), 0)
     1705
     1706    $tip.addClass('in')
     1707
     1708    // check to see if placing tip in new offset caused the tip to resize itself
     1709    var actualWidth  = $tip[0].offsetWidth
     1710    var actualHeight = $tip[0].offsetHeight
     1711
     1712    if (placement == 'top' && actualHeight != height) {
     1713      offset.top = offset.top + height - actualHeight
     1714    }
     1715
     1716    var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
     1717
     1718    if (delta.left) offset.left += delta.left
     1719    else offset.top += delta.top
     1720
     1721    var isVertical          = /top|bottom/.test(placement)
     1722    var arrowDelta          = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
     1723    var arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight'
     1724
     1725    $tip.offset(offset)
     1726    this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], isVertical)
     1727  }
     1728
     1729  Tooltip.prototype.replaceArrow = function (delta, dimension, isVertical) {
     1730    this.arrow()
     1731      .css(isVertical ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')
     1732      .css(isVertical ? 'top' : 'left', '')
     1733  }
     1734
     1735  Tooltip.prototype.setContent = function () {
     1736    var $tip  = this.tip()
     1737    var title = this.getTitle()
     1738
     1739    if (this.options.html) {
     1740      if (this.options.sanitize) {
     1741        title = sanitizeHtml(title, this.options.whiteList, this.options.sanitizeFn)
     1742      }
     1743
     1744      $tip.find('.tooltip-inner').html(title)
     1745    } else {
     1746      $tip.find('.tooltip-inner').text(title)
     1747    }
     1748
     1749    $tip.removeClass('fade in top bottom left right')
     1750  }
     1751
     1752  Tooltip.prototype.hide = function (callback) {
     1753    var that = this
     1754    var $tip = $(this.$tip)
     1755    var e    = $.Event('hide.bs.' + this.type)
     1756
     1757    function complete() {
     1758      if (that.hoverState != 'in') $tip.detach()
     1759      if (that.$element) { // TODO: Check whether guarding this code with this `if` is really necessary.
     1760        that.$element
     1761          .removeAttr('aria-describedby')
     1762          .trigger('hidden.bs.' + that.type)
     1763      }
     1764      callback && callback()
     1765    }
     1766
     1767    this.$element.trigger(e)
     1768
     1769    if (e.isDefaultPrevented()) return
     1770
     1771    $tip.removeClass('in')
     1772
     1773    $.support.transition && $tip.hasClass('fade') ?
     1774      $tip
     1775        .one('bsTransitionEnd', complete)
     1776        .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
     1777      complete()
     1778
     1779    this.hoverState = null
     1780
     1781    return this
     1782  }
     1783
     1784  Tooltip.prototype.fixTitle = function () {
     1785    var $e = this.$element
     1786    if ($e.attr('title') || typeof $e.attr('data-original-title') != 'string') {
     1787      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
     1788    }
     1789  }
     1790
     1791  Tooltip.prototype.hasContent = function () {
     1792    return this.getTitle()
     1793  }
     1794
     1795  Tooltip.prototype.getPosition = function ($element) {
     1796    $element   = $element || this.$element
     1797
     1798    var el     = $element[0]
     1799    var isBody = el.tagName == 'BODY'
     1800
     1801    var elRect    = el.getBoundingClientRect()
     1802    if (elRect.width == null) {
     1803      // width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093
     1804      elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })
     1805    }
     1806    var isSvg = window.SVGElement && el instanceof window.SVGElement
     1807    // Avoid using $.offset() on SVGs since it gives incorrect results in jQuery 3.
     1808    // See https://github.com/twbs/bootstrap/issues/20280
     1809    var elOffset  = isBody ? { top: 0, left: 0 } : (isSvg ? null : $element.offset())
     1810    var scroll    = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }
     1811    var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null
     1812
     1813    return $.extend({}, elRect, scroll, outerDims, elOffset)
     1814  }
     1815
     1816  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
     1817    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2 } :
     1818           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
     1819           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
     1820        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
     1821
     1822  }
     1823
     1824  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
     1825    var delta = { top: 0, left: 0 }
     1826    if (!this.$viewport) return delta
     1827
     1828    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
     1829    var viewportDimensions = this.getPosition(this.$viewport)
     1830
     1831    if (/right|left/.test(placement)) {
     1832      var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll
     1833      var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
     1834      if (topEdgeOffset < viewportDimensions.top) { // top overflow
     1835        delta.top = viewportDimensions.top - topEdgeOffset
     1836      } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
     1837        delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
     1838      }
     1839    } else {
     1840      var leftEdgeOffset  = pos.left - viewportPadding
     1841      var rightEdgeOffset = pos.left + viewportPadding + actualWidth
     1842      if (leftEdgeOffset < viewportDimensions.left) { // left overflow
     1843        delta.left = viewportDimensions.left - leftEdgeOffset
     1844      } else if (rightEdgeOffset > viewportDimensions.right) { // right overflow
     1845        delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
     1846      }
     1847    }
     1848
     1849    return delta
     1850  }
     1851
     1852  Tooltip.prototype.getTitle = function () {
     1853    var title
     1854    var $e = this.$element
     1855    var o  = this.options
     1856
     1857    title = $e.attr('data-original-title')
     1858      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
     1859
     1860    return title
     1861  }
     1862
     1863  Tooltip.prototype.getUID = function (prefix) {
     1864    do prefix += ~~(Math.random() * 1000000)
     1865    while (document.getElementById(prefix))
     1866    return prefix
     1867  }
     1868
     1869  Tooltip.prototype.tip = function () {
     1870    if (!this.$tip) {
     1871      this.$tip = $(this.options.template)
     1872      if (this.$tip.length != 1) {
     1873        throw new Error(this.type + ' `template` option must consist of exactly 1 top-level element!')
     1874      }
     1875    }
     1876    return this.$tip
     1877  }
     1878
     1879  Tooltip.prototype.arrow = function () {
     1880    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
     1881  }
     1882
     1883  Tooltip.prototype.enable = function () {
     1884    this.enabled = true
     1885  }
     1886
     1887  Tooltip.prototype.disable = function () {
     1888    this.enabled = false
     1889  }
     1890
     1891  Tooltip.prototype.toggleEnabled = function () {
     1892    this.enabled = !this.enabled
     1893  }
     1894
     1895  Tooltip.prototype.toggle = function (e) {
     1896    var self = this
     1897    if (e) {
     1898      self = $(e.currentTarget).data('bs.' + this.type)
     1899      if (!self) {
     1900        self = new this.constructor(e.currentTarget, this.getDelegateOptions())
     1901        $(e.currentTarget).data('bs.' + this.type, self)
     1902      }
     1903    }
     1904
     1905    if (e) {
     1906      self.inState.click = !self.inState.click
     1907      if (self.isInStateTrue()) self.enter(self)
     1908      else self.leave(self)
     1909    } else {
     1910      self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
     1911    }
     1912  }
     1913
     1914  Tooltip.prototype.destroy = function () {
     1915    var that = this
     1916    clearTimeout(this.timeout)
     1917    this.hide(function () {
     1918      that.$element.off('.' + that.type).removeData('bs.' + that.type)
     1919      if (that.$tip) {
     1920        that.$tip.detach()
     1921      }
     1922      that.$tip = null
     1923      that.$arrow = null
     1924      that.$viewport = null
     1925      that.$element = null
     1926    })
     1927  }
     1928
     1929  Tooltip.prototype.sanitizeHtml = function (unsafeHtml) {
     1930    return sanitizeHtml(unsafeHtml, this.options.whiteList, this.options.sanitizeFn)
     1931  }
     1932
     1933  // TOOLTIP PLUGIN DEFINITION
     1934  // =========================
     1935
     1936  function Plugin(option) {
     1937    return this.each(function () {
     1938      var $this   = $(this)
     1939      var data    = $this.data('bs.tooltip')
     1940      var options = typeof option == 'object' && option
     1941
     1942      if (!data && /destroy|hide/.test(option)) return
     1943      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
     1944      if (typeof option == 'string') data[option]()
     1945    })
     1946  }
     1947
     1948  var old = $.fn.tooltip
     1949
     1950  $.fn.tooltip             = Plugin
     1951  $.fn.tooltip.Constructor = Tooltip
     1952
     1953
     1954  // TOOLTIP NO CONFLICT
     1955  // ===================
     1956
     1957  $.fn.tooltip.noConflict = function () {
     1958    $.fn.tooltip = old
     1959    return this
     1960  }
     1961
     1962}(jQuery);
     1963
     1964/* ========================================================================
     1965 * Bootstrap: popover.js v3.4.1
     1966 * https://getbootstrap.com/docs/3.4/javascript/#popovers
     1967 * ========================================================================
     1968 * Copyright 2011-2019 Twitter, Inc.
     1969 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     1970 * ======================================================================== */
     1971
     1972
     1973+function ($) {
     1974  'use strict';
     1975
     1976  // POPOVER PUBLIC CLASS DEFINITION
     1977  // ===============================
     1978
     1979  var Popover = function (element, options) {
     1980    this.init('popover', element, options)
     1981  }
     1982
     1983  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
     1984
     1985  Popover.VERSION  = '3.4.1'
     1986
     1987  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
    42661988    placement: 'right',
    4267     offset: [0, 8],
    42681989    trigger: 'click',
    42691990    content: '',
    4270     template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>'
    4271   };
    4272   const DefaultType$2 = { ...Tooltip.DefaultType,
    4273     content: '(string|element|function)'
    4274   };
    4275   const Event$1 = {
    4276     HIDE: `hide${EVENT_KEY$3}`,
    4277     HIDDEN: `hidden${EVENT_KEY$3}`,
    4278     SHOW: `show${EVENT_KEY$3}`,
    4279     SHOWN: `shown${EVENT_KEY$3}`,
    4280     INSERTED: `inserted${EVENT_KEY$3}`,
    4281     CLICK: `click${EVENT_KEY$3}`,
    4282     FOCUSIN: `focusin${EVENT_KEY$3}`,
    4283     FOCUSOUT: `focusout${EVENT_KEY$3}`,
    4284     MOUSEENTER: `mouseenter${EVENT_KEY$3}`,
    4285     MOUSELEAVE: `mouseleave${EVENT_KEY$3}`
    4286   };
    4287   const SELECTOR_TITLE = '.popover-header';
    4288   const SELECTOR_CONTENT = '.popover-body';
    4289   /**
    4290    * ------------------------------------------------------------------------
    4291    * Class Definition
    4292    * ------------------------------------------------------------------------
    4293    */
    4294 
    4295   class Popover extends Tooltip {
    4296     // Getters
    4297     static get Default() {
    4298       return Default$2;
    4299     }
    4300 
    4301     static get NAME() {
    4302       return NAME$3;
    4303     }
    4304 
    4305     static get Event() {
    4306       return Event$1;
    4307     }
    4308 
    4309     static get DefaultType() {
    4310       return DefaultType$2;
    4311     } // Overrides
    4312 
    4313 
    4314     isWithContent() {
    4315       return this.getTitle() || this._getContent();
    4316     }
    4317 
    4318     setContent(tip) {
    4319       this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE);
    4320 
    4321       this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT);
    4322     } // Private
    4323 
    4324 
    4325     _getContent() {
    4326       return this._resolvePossibleFunction(this._config.content);
    4327     }
    4328 
    4329     _getBasicClassPrefix() {
    4330       return CLASS_PREFIX;
    4331     } // Static
    4332 
    4333 
    4334     static jQueryInterface(config) {
    4335       return this.each(function () {
    4336         const data = Popover.getOrCreateInstance(this, config);
    4337 
    4338         if (typeof config === 'string') {
    4339           if (typeof data[config] === 'undefined') {
    4340             throw new TypeError(`No method named "${config}"`);
    4341           }
    4342 
    4343           data[config]();
     1991    template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
     1992  })
     1993
     1994
     1995  // NOTE: POPOVER EXTENDS tooltip.js
     1996  // ================================
     1997
     1998  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
     1999
     2000  Popover.prototype.constructor = Popover
     2001
     2002  Popover.prototype.getDefaults = function () {
     2003    return Popover.DEFAULTS
     2004  }
     2005
     2006  Popover.prototype.setContent = function () {
     2007    var $tip    = this.tip()
     2008    var title   = this.getTitle()
     2009    var content = this.getContent()
     2010
     2011    if (this.options.html) {
     2012      var typeContent = typeof content
     2013
     2014      if (this.options.sanitize) {
     2015        title = this.sanitizeHtml(title)
     2016
     2017        if (typeContent === 'string') {
     2018          content = this.sanitizeHtml(content)
    43442019        }
    4345       });
    4346     }
    4347 
    4348   }
    4349   /**
    4350    * ------------------------------------------------------------------------
    4351    * jQuery
    4352    * ------------------------------------------------------------------------
    4353    * add .Popover to jQuery only if jQuery is present
    4354    */
    4355 
    4356 
    4357   defineJQueryPlugin(Popover);
    4358 
    4359   /**
    4360    * --------------------------------------------------------------------------
    4361    * Bootstrap (v5.1.3): scrollspy.js
    4362    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    4363    * --------------------------------------------------------------------------
    4364    */
    4365   /**
    4366    * ------------------------------------------------------------------------
    4367    * Constants
    4368    * ------------------------------------------------------------------------
    4369    */
    4370 
    4371   const NAME$2 = 'scrollspy';
    4372   const DATA_KEY$2 = 'bs.scrollspy';
    4373   const EVENT_KEY$2 = `.${DATA_KEY$2}`;
    4374   const DATA_API_KEY$1 = '.data-api';
    4375   const Default$1 = {
    4376     offset: 10,
    4377     method: 'auto',
    4378     target: ''
    4379   };
    4380   const DefaultType$1 = {
    4381     offset: 'number',
    4382     method: 'string',
    4383     target: '(string|element)'
    4384   };
    4385   const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
    4386   const EVENT_SCROLL = `scroll${EVENT_KEY$2}`;
    4387   const EVENT_LOAD_DATA_API = `load${EVENT_KEY$2}${DATA_API_KEY$1}`;
    4388   const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
    4389   const CLASS_NAME_ACTIVE$1 = 'active';
    4390   const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
    4391   const SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group';
    4392   const SELECTOR_NAV_LINKS = '.nav-link';
    4393   const SELECTOR_NAV_ITEMS = '.nav-item';
    4394   const SELECTOR_LIST_ITEMS = '.list-group-item';
    4395   const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}, .${CLASS_NAME_DROPDOWN_ITEM}`;
    4396   const SELECTOR_DROPDOWN$1 = '.dropdown';
    4397   const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
    4398   const METHOD_OFFSET = 'offset';
    4399   const METHOD_POSITION = 'position';
    4400   /**
    4401    * ------------------------------------------------------------------------
    4402    * Class Definition
    4403    * ------------------------------------------------------------------------
    4404    */
    4405 
    4406   class ScrollSpy extends BaseComponent {
    4407     constructor(element, config) {
    4408       super(element);
    4409       this._scrollElement = this._element.tagName === 'BODY' ? window : this._element;
    4410       this._config = this._getConfig(config);
    4411       this._offsets = [];
    4412       this._targets = [];
    4413       this._activeTarget = null;
    4414       this._scrollHeight = 0;
    4415       EventHandler.on(this._scrollElement, EVENT_SCROLL, () => this._process());
    4416       this.refresh();
    4417 
    4418       this._process();
    4419     } // Getters
    4420 
    4421 
    4422     static get Default() {
    4423       return Default$1;
    4424     }
    4425 
    4426     static get NAME() {
    4427       return NAME$2;
    4428     } // Public
    4429 
    4430 
    4431     refresh() {
    4432       const autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
    4433       const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
    4434       const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
    4435       this._offsets = [];
    4436       this._targets = [];
    4437       this._scrollHeight = this._getScrollHeight();
    4438       const targets = SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target);
    4439       targets.map(element => {
    4440         const targetSelector = getSelectorFromElement(element);
    4441         const target = targetSelector ? SelectorEngine.findOne(targetSelector) : null;
    4442 
    4443         if (target) {
    4444           const targetBCR = target.getBoundingClientRect();
    4445 
    4446           if (targetBCR.width || targetBCR.height) {
    4447             return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector];
    4448           }
    4449         }
    4450 
    4451         return null;
    4452       }).filter(item => item).sort((a, b) => a[0] - b[0]).forEach(item => {
    4453         this._offsets.push(item[0]);
    4454 
    4455         this._targets.push(item[1]);
    4456       });
    4457     }
    4458 
    4459     dispose() {
    4460       EventHandler.off(this._scrollElement, EVENT_KEY$2);
    4461       super.dispose();
    4462     } // Private
    4463 
    4464 
    4465     _getConfig(config) {
    4466       config = { ...Default$1,
    4467         ...Manipulator.getDataAttributes(this._element),
    4468         ...(typeof config === 'object' && config ? config : {})
    4469       };
    4470       config.target = getElement(config.target) || document.documentElement;
    4471       typeCheckConfig(NAME$2, config, DefaultType$1);
    4472       return config;
    4473     }
    4474 
    4475     _getScrollTop() {
    4476       return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
    4477     }
    4478 
    4479     _getScrollHeight() {
    4480       return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
    4481     }
    4482 
    4483     _getOffsetHeight() {
    4484       return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
    4485     }
    4486 
    4487     _process() {
    4488       const scrollTop = this._getScrollTop() + this._config.offset;
    4489 
    4490       const scrollHeight = this._getScrollHeight();
    4491 
    4492       const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
    4493 
    4494       if (this._scrollHeight !== scrollHeight) {
    4495         this.refresh();
    4496       }
    4497 
    4498       if (scrollTop >= maxScroll) {
    4499         const target = this._targets[this._targets.length - 1];
    4500 
    4501         if (this._activeTarget !== target) {
    4502           this._activate(target);
    4503         }
    4504 
    4505         return;
    4506       }
    4507 
    4508       if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
    4509         this._activeTarget = null;
    4510 
    4511         this._clear();
    4512 
    4513         return;
    4514       }
    4515 
    4516       for (let i = this._offsets.length; i--;) {
    4517         const isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
    4518 
    4519         if (isActiveTarget) {
    4520           this._activate(this._targets[i]);
    4521         }
    4522       }
    4523     }
    4524 
    4525     _activate(target) {
    4526       this._activeTarget = target;
    4527 
    4528       this._clear();
    4529 
    4530       const queries = SELECTOR_LINK_ITEMS.split(',').map(selector => `${selector}[data-bs-target="${target}"],${selector}[href="${target}"]`);
    4531       const link = SelectorEngine.findOne(queries.join(','), this._config.target);
    4532       link.classList.add(CLASS_NAME_ACTIVE$1);
    4533 
    4534       if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
    4535         SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, link.closest(SELECTOR_DROPDOWN$1)).classList.add(CLASS_NAME_ACTIVE$1);
     2020      }
     2021
     2022      $tip.find('.popover-title').html(title)
     2023      $tip.find('.popover-content').children().detach().end()[
     2024        typeContent === 'string' ? 'html' : 'append'
     2025      ](content)
     2026    } else {
     2027      $tip.find('.popover-title').text(title)
     2028      $tip.find('.popover-content').children().detach().end().text(content)
     2029    }
     2030
     2031    $tip.removeClass('fade top bottom left right in')
     2032
     2033    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
     2034    // this manually by checking the contents.
     2035    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
     2036  }
     2037
     2038  Popover.prototype.hasContent = function () {
     2039    return this.getTitle() || this.getContent()
     2040  }
     2041
     2042  Popover.prototype.getContent = function () {
     2043    var $e = this.$element
     2044    var o  = this.options
     2045
     2046    return $e.attr('data-content')
     2047      || (typeof o.content == 'function' ?
     2048        o.content.call($e[0]) :
     2049        o.content)
     2050  }
     2051
     2052  Popover.prototype.arrow = function () {
     2053    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
     2054  }
     2055
     2056
     2057  // POPOVER PLUGIN DEFINITION
     2058  // =========================
     2059
     2060  function Plugin(option) {
     2061    return this.each(function () {
     2062      var $this   = $(this)
     2063      var data    = $this.data('bs.popover')
     2064      var options = typeof option == 'object' && option
     2065
     2066      if (!data && /destroy|hide/.test(option)) return
     2067      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
     2068      if (typeof option == 'string') data[option]()
     2069    })
     2070  }
     2071
     2072  var old = $.fn.popover
     2073
     2074  $.fn.popover             = Plugin
     2075  $.fn.popover.Constructor = Popover
     2076
     2077
     2078  // POPOVER NO CONFLICT
     2079  // ===================
     2080
     2081  $.fn.popover.noConflict = function () {
     2082    $.fn.popover = old
     2083    return this
     2084  }
     2085
     2086}(jQuery);
     2087
     2088/* ========================================================================
     2089 * Bootstrap: scrollspy.js v3.4.1
     2090 * https://getbootstrap.com/docs/3.4/javascript/#scrollspy
     2091 * ========================================================================
     2092 * Copyright 2011-2019 Twitter, Inc.
     2093 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     2094 * ======================================================================== */
     2095
     2096
     2097+function ($) {
     2098  'use strict';
     2099
     2100  // SCROLLSPY CLASS DEFINITION
     2101  // ==========================
     2102
     2103  function ScrollSpy(element, options) {
     2104    this.$body          = $(document.body)
     2105    this.$scrollElement = $(element).is(document.body) ? $(window) : $(element)
     2106    this.options        = $.extend({}, ScrollSpy.DEFAULTS, options)
     2107    this.selector       = (this.options.target || '') + ' .nav li > a'
     2108    this.offsets        = []
     2109    this.targets        = []
     2110    this.activeTarget   = null
     2111    this.scrollHeight   = 0
     2112
     2113    this.$scrollElement.on('scroll.bs.scrollspy', $.proxy(this.process, this))
     2114    this.refresh()
     2115    this.process()
     2116  }
     2117
     2118  ScrollSpy.VERSION  = '3.4.1'
     2119
     2120  ScrollSpy.DEFAULTS = {
     2121    offset: 10
     2122  }
     2123
     2124  ScrollSpy.prototype.getScrollHeight = function () {
     2125    return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
     2126  }
     2127
     2128  ScrollSpy.prototype.refresh = function () {
     2129    var that          = this
     2130    var offsetMethod  = 'offset'
     2131    var offsetBase    = 0
     2132
     2133    this.offsets      = []
     2134    this.targets      = []
     2135    this.scrollHeight = this.getScrollHeight()
     2136
     2137    if (!$.isWindow(this.$scrollElement[0])) {
     2138      offsetMethod = 'position'
     2139      offsetBase   = this.$scrollElement.scrollTop()
     2140    }
     2141
     2142    this.$body
     2143      .find(this.selector)
     2144      .map(function () {
     2145        var $el   = $(this)
     2146        var href  = $el.data('target') || $el.attr('href')
     2147        var $href = /^#./.test(href) && $(href)
     2148
     2149        return ($href
     2150          && $href.length
     2151          && $href.is(':visible')
     2152          && [[$href[offsetMethod]().top + offsetBase, href]]) || null
     2153      })
     2154      .sort(function (a, b) { return a[0] - b[0] })
     2155      .each(function () {
     2156        that.offsets.push(this[0])
     2157        that.targets.push(this[1])
     2158      })
     2159  }
     2160
     2161  ScrollSpy.prototype.process = function () {
     2162    var scrollTop    = this.$scrollElement.scrollTop() + this.options.offset
     2163    var scrollHeight = this.getScrollHeight()
     2164    var maxScroll    = this.options.offset + scrollHeight - this.$scrollElement.height()
     2165    var offsets      = this.offsets
     2166    var targets      = this.targets
     2167    var activeTarget = this.activeTarget
     2168    var i
     2169
     2170    if (this.scrollHeight != scrollHeight) {
     2171      this.refresh()
     2172    }
     2173
     2174    if (scrollTop >= maxScroll) {
     2175      return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
     2176    }
     2177
     2178    if (activeTarget && scrollTop < offsets[0]) {
     2179      this.activeTarget = null
     2180      return this.clear()
     2181    }
     2182
     2183    for (i = offsets.length; i--;) {
     2184      activeTarget != targets[i]
     2185        && scrollTop >= offsets[i]
     2186        && (offsets[i + 1] === undefined || scrollTop < offsets[i + 1])
     2187        && this.activate(targets[i])
     2188    }
     2189  }
     2190
     2191  ScrollSpy.prototype.activate = function (target) {
     2192    this.activeTarget = target
     2193
     2194    this.clear()
     2195
     2196    var selector = this.selector +
     2197      '[data-target="' + target + '"],' +
     2198      this.selector + '[href="' + target + '"]'
     2199
     2200    var active = $(selector)
     2201      .parents('li')
     2202      .addClass('active')
     2203
     2204    if (active.parent('.dropdown-menu').length) {
     2205      active = active
     2206        .closest('li.dropdown')
     2207        .addClass('active')
     2208    }
     2209
     2210    active.trigger('activate.bs.scrollspy')
     2211  }
     2212
     2213  ScrollSpy.prototype.clear = function () {
     2214    $(this.selector)
     2215      .parentsUntil(this.options.target, '.active')
     2216      .removeClass('active')
     2217  }
     2218
     2219
     2220  // SCROLLSPY PLUGIN DEFINITION
     2221  // ===========================
     2222
     2223  function Plugin(option) {
     2224    return this.each(function () {
     2225      var $this   = $(this)
     2226      var data    = $this.data('bs.scrollspy')
     2227      var options = typeof option == 'object' && option
     2228
     2229      if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
     2230      if (typeof option == 'string') data[option]()
     2231    })
     2232  }
     2233
     2234  var old = $.fn.scrollspy
     2235
     2236  $.fn.scrollspy             = Plugin
     2237  $.fn.scrollspy.Constructor = ScrollSpy
     2238
     2239
     2240  // SCROLLSPY NO CONFLICT
     2241  // =====================
     2242
     2243  $.fn.scrollspy.noConflict = function () {
     2244    $.fn.scrollspy = old
     2245    return this
     2246  }
     2247
     2248
     2249  // SCROLLSPY DATA-API
     2250  // ==================
     2251
     2252  $(window).on('load.bs.scrollspy.data-api', function () {
     2253    $('[data-spy="scroll"]').each(function () {
     2254      var $spy = $(this)
     2255      Plugin.call($spy, $spy.data())
     2256    })
     2257  })
     2258
     2259}(jQuery);
     2260
     2261/* ========================================================================
     2262 * Bootstrap: tab.js v3.4.1
     2263 * https://getbootstrap.com/docs/3.4/javascript/#tabs
     2264 * ========================================================================
     2265 * Copyright 2011-2019 Twitter, Inc.
     2266 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     2267 * ======================================================================== */
     2268
     2269
     2270+function ($) {
     2271  'use strict';
     2272
     2273  // TAB CLASS DEFINITION
     2274  // ====================
     2275
     2276  var Tab = function (element) {
     2277    // jscs:disable requireDollarBeforejQueryAssignment
     2278    this.element = $(element)
     2279    // jscs:enable requireDollarBeforejQueryAssignment
     2280  }
     2281
     2282  Tab.VERSION = '3.4.1'
     2283
     2284  Tab.TRANSITION_DURATION = 150
     2285
     2286  Tab.prototype.show = function () {
     2287    var $this    = this.element
     2288    var $ul      = $this.closest('ul:not(.dropdown-menu)')
     2289    var selector = $this.data('target')
     2290
     2291    if (!selector) {
     2292      selector = $this.attr('href')
     2293      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
     2294    }
     2295
     2296    if ($this.parent('li').hasClass('active')) return
     2297
     2298    var $previous = $ul.find('.active:last a')
     2299    var hideEvent = $.Event('hide.bs.tab', {
     2300      relatedTarget: $this[0]
     2301    })
     2302    var showEvent = $.Event('show.bs.tab', {
     2303      relatedTarget: $previous[0]
     2304    })
     2305
     2306    $previous.trigger(hideEvent)
     2307    $this.trigger(showEvent)
     2308
     2309    if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return
     2310
     2311    var $target = $(document).find(selector)
     2312
     2313    this.activate($this.closest('li'), $ul)
     2314    this.activate($target, $target.parent(), function () {
     2315      $previous.trigger({
     2316        type: 'hidden.bs.tab',
     2317        relatedTarget: $this[0]
     2318      })
     2319      $this.trigger({
     2320        type: 'shown.bs.tab',
     2321        relatedTarget: $previous[0]
     2322      })
     2323    })
     2324  }
     2325
     2326  Tab.prototype.activate = function (element, container, callback) {
     2327    var $active    = container.find('> .active')
     2328    var transition = callback
     2329      && $.support.transition
     2330      && ($active.length && $active.hasClass('fade') || !!container.find('> .fade').length)
     2331
     2332    function next() {
     2333      $active
     2334        .removeClass('active')
     2335        .find('> .dropdown-menu > .active')
     2336        .removeClass('active')
     2337        .end()
     2338        .find('[data-toggle="tab"]')
     2339        .attr('aria-expanded', false)
     2340
     2341      element
     2342        .addClass('active')
     2343        .find('[data-toggle="tab"]')
     2344        .attr('aria-expanded', true)
     2345
     2346      if (transition) {
     2347        element[0].offsetWidth // reflow for transition
     2348        element.addClass('in')
    45362349      } else {
    4537         SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP$1).forEach(listGroup => {
    4538           // Set triggered links parents as active
    4539           // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
    4540           SelectorEngine.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1)); // Handle special case when .nav-link is inside .nav-item
    4541 
    4542           SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(navItem => {
    4543             SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1));
    4544           });
    4545         });
    4546       }
    4547 
    4548       EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, {
    4549         relatedTarget: target
    4550       });
    4551     }
    4552 
    4553     _clear() {
    4554       SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target).filter(node => node.classList.contains(CLASS_NAME_ACTIVE$1)).forEach(node => node.classList.remove(CLASS_NAME_ACTIVE$1));
    4555     } // Static
    4556 
    4557 
    4558     static jQueryInterface(config) {
    4559       return this.each(function () {
    4560         const data = ScrollSpy.getOrCreateInstance(this, config);
    4561 
    4562         if (typeof config !== 'string') {
    4563           return;
    4564         }
    4565 
    4566         if (typeof data[config] === 'undefined') {
    4567           throw new TypeError(`No method named "${config}"`);
    4568         }
    4569 
    4570         data[config]();
    4571       });
    4572     }
    4573 
    4574   }
    4575   /**
    4576    * ------------------------------------------------------------------------
    4577    * Data Api implementation
    4578    * ------------------------------------------------------------------------
    4579    */
    4580 
    4581 
    4582   EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
    4583     SelectorEngine.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy));
    4584   });
    4585   /**
    4586    * ------------------------------------------------------------------------
    4587    * jQuery
    4588    * ------------------------------------------------------------------------
    4589    * add .ScrollSpy to jQuery only if jQuery is present
    4590    */
    4591 
    4592   defineJQueryPlugin(ScrollSpy);
    4593 
    4594   /**
    4595    * --------------------------------------------------------------------------
    4596    * Bootstrap (v5.1.3): tab.js
    4597    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    4598    * --------------------------------------------------------------------------
    4599    */
    4600   /**
    4601    * ------------------------------------------------------------------------
    4602    * Constants
    4603    * ------------------------------------------------------------------------
    4604    */
    4605 
    4606   const NAME$1 = 'tab';
    4607   const DATA_KEY$1 = 'bs.tab';
    4608   const EVENT_KEY$1 = `.${DATA_KEY$1}`;
    4609   const DATA_API_KEY = '.data-api';
    4610   const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
    4611   const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
    4612   const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
    4613   const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
    4614   const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}${DATA_API_KEY}`;
    4615   const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
    4616   const CLASS_NAME_ACTIVE = 'active';
    4617   const CLASS_NAME_FADE$1 = 'fade';
    4618   const CLASS_NAME_SHOW$1 = 'show';
    4619   const SELECTOR_DROPDOWN = '.dropdown';
    4620   const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
    4621   const SELECTOR_ACTIVE = '.active';
    4622   const SELECTOR_ACTIVE_UL = ':scope > li > .active';
    4623   const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
    4624   const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
    4625   const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
    4626   /**
    4627    * ------------------------------------------------------------------------
    4628    * Class Definition
    4629    * ------------------------------------------------------------------------
    4630    */
    4631 
    4632   class Tab extends BaseComponent {
    4633     // Getters
    4634     static get NAME() {
    4635       return NAME$1;
    4636     } // Public
    4637 
    4638 
    4639     show() {
    4640       if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) {
    4641         return;
    4642       }
    4643 
    4644       let previous;
    4645       const target = getElementFromSelector(this._element);
    4646 
    4647       const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);
    4648 
    4649       if (listElement) {
    4650         const itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE;
    4651         previous = SelectorEngine.find(itemSelector, listElement);
    4652         previous = previous[previous.length - 1];
    4653       }
    4654 
    4655       const hideEvent = previous ? EventHandler.trigger(previous, EVENT_HIDE$1, {
    4656         relatedTarget: this._element
    4657       }) : null;
    4658       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, {
    4659         relatedTarget: previous
    4660       });
    4661 
    4662       if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) {
    4663         return;
    4664       }
    4665 
    4666       this._activate(this._element, listElement);
    4667 
    4668       const complete = () => {
    4669         EventHandler.trigger(previous, EVENT_HIDDEN$1, {
    4670           relatedTarget: this._element
    4671         });
    4672         EventHandler.trigger(this._element, EVENT_SHOWN$1, {
    4673           relatedTarget: previous
    4674         });
    4675       };
    4676 
    4677       if (target) {
    4678         this._activate(target, target.parentNode, complete);
    4679       } else {
    4680         complete();
    4681       }
    4682     } // Private
    4683 
    4684 
    4685     _activate(element, container, callback) {
    4686       const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine.children(container, SELECTOR_ACTIVE);
    4687       const active = activeElements[0];
    4688       const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE$1);
    4689 
    4690       const complete = () => this._transitionComplete(element, active, callback);
    4691 
    4692       if (active && isTransitioning) {
    4693         active.classList.remove(CLASS_NAME_SHOW$1);
    4694 
    4695         this._queueCallback(complete, element, true);
    4696       } else {
    4697         complete();
    4698       }
    4699     }
    4700 
    4701     _transitionComplete(element, active, callback) {
    4702       if (active) {
    4703         active.classList.remove(CLASS_NAME_ACTIVE);
    4704         const dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode);
    4705 
    4706         if (dropdownChild) {
    4707           dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
    4708         }
    4709 
    4710         if (active.getAttribute('role') === 'tab') {
    4711           active.setAttribute('aria-selected', false);
    4712         }
    4713       }
    4714 
    4715       element.classList.add(CLASS_NAME_ACTIVE);
    4716 
    4717       if (element.getAttribute('role') === 'tab') {
    4718         element.setAttribute('aria-selected', true);
    4719       }
    4720 
    4721       reflow(element);
    4722 
    4723       if (element.classList.contains(CLASS_NAME_FADE$1)) {
    4724         element.classList.add(CLASS_NAME_SHOW$1);
    4725       }
    4726 
    4727       let parent = element.parentNode;
    4728 
    4729       if (parent && parent.nodeName === 'LI') {
    4730         parent = parent.parentNode;
    4731       }
    4732 
    4733       if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
    4734         const dropdownElement = element.closest(SELECTOR_DROPDOWN);
    4735 
    4736         if (dropdownElement) {
    4737           SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE));
    4738         }
    4739 
    4740         element.setAttribute('aria-expanded', true);
    4741       }
    4742 
    4743       if (callback) {
    4744         callback();
    4745       }
    4746     } // Static
    4747 
    4748 
    4749     static jQueryInterface(config) {
    4750       return this.each(function () {
    4751         const data = Tab.getOrCreateInstance(this);
    4752 
    4753         if (typeof config === 'string') {
    4754           if (typeof data[config] === 'undefined') {
    4755             throw new TypeError(`No method named "${config}"`);
    4756           }
    4757 
    4758           data[config]();
    4759         }
    4760       });
    4761     }
    4762 
    4763   }
    4764   /**
    4765    * ------------------------------------------------------------------------
    4766    * Data Api implementation
    4767    * ------------------------------------------------------------------------
    4768    */
    4769 
    4770 
    4771   EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
    4772     if (['A', 'AREA'].includes(this.tagName)) {
    4773       event.preventDefault();
    4774     }
    4775 
    4776     if (isDisabled(this)) {
    4777       return;
    4778     }
    4779 
    4780     const data = Tab.getOrCreateInstance(this);
    4781     data.show();
    4782   });
    4783   /**
    4784    * ------------------------------------------------------------------------
    4785    * jQuery
    4786    * ------------------------------------------------------------------------
    4787    * add .Tab to jQuery only if jQuery is present
    4788    */
    4789 
    4790   defineJQueryPlugin(Tab);
    4791 
    4792   /**
    4793    * --------------------------------------------------------------------------
    4794    * Bootstrap (v5.1.3): toast.js
    4795    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    4796    * --------------------------------------------------------------------------
    4797    */
    4798   /**
    4799    * ------------------------------------------------------------------------
    4800    * Constants
    4801    * ------------------------------------------------------------------------
    4802    */
    4803 
    4804   const NAME = 'toast';
    4805   const DATA_KEY = 'bs.toast';
    4806   const EVENT_KEY = `.${DATA_KEY}`;
    4807   const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
    4808   const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
    4809   const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
    4810   const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
    4811   const EVENT_HIDE = `hide${EVENT_KEY}`;
    4812   const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
    4813   const EVENT_SHOW = `show${EVENT_KEY}`;
    4814   const EVENT_SHOWN = `shown${EVENT_KEY}`;
    4815   const CLASS_NAME_FADE = 'fade';
    4816   const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
    4817 
    4818   const CLASS_NAME_SHOW = 'show';
    4819   const CLASS_NAME_SHOWING = 'showing';
    4820   const DefaultType = {
    4821     animation: 'boolean',
    4822     autohide: 'boolean',
    4823     delay: 'number'
    4824   };
    4825   const Default = {
    4826     animation: true,
    4827     autohide: true,
    4828     delay: 5000
    4829   };
    4830   /**
    4831    * ------------------------------------------------------------------------
    4832    * Class Definition
    4833    * ------------------------------------------------------------------------
    4834    */
    4835 
    4836   class Toast extends BaseComponent {
    4837     constructor(element, config) {
    4838       super(element);
    4839       this._config = this._getConfig(config);
    4840       this._timeout = null;
    4841       this._hasMouseInteraction = false;
    4842       this._hasKeyboardInteraction = false;
    4843 
    4844       this._setListeners();
    4845     } // Getters
    4846 
    4847 
    4848     static get DefaultType() {
    4849       return DefaultType;
    4850     }
    4851 
    4852     static get Default() {
    4853       return Default;
    4854     }
    4855 
    4856     static get NAME() {
    4857       return NAME;
    4858     } // Public
    4859 
    4860 
    4861     show() {
    4862       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
    4863 
    4864       if (showEvent.defaultPrevented) {
    4865         return;
    4866       }
    4867 
    4868       this._clearTimeout();
    4869 
    4870       if (this._config.animation) {
    4871         this._element.classList.add(CLASS_NAME_FADE);
    4872       }
    4873 
    4874       const complete = () => {
    4875         this._element.classList.remove(CLASS_NAME_SHOWING);
    4876 
    4877         EventHandler.trigger(this._element, EVENT_SHOWN);
    4878 
    4879         this._maybeScheduleHide();
    4880       };
    4881 
    4882       this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
    4883 
    4884 
    4885       reflow(this._element);
    4886 
    4887       this._element.classList.add(CLASS_NAME_SHOW);
    4888 
    4889       this._element.classList.add(CLASS_NAME_SHOWING);
    4890 
    4891       this._queueCallback(complete, this._element, this._config.animation);
    4892     }
    4893 
    4894     hide() {
    4895       if (!this._element.classList.contains(CLASS_NAME_SHOW)) {
    4896         return;
    4897       }
    4898 
    4899       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
    4900 
    4901       if (hideEvent.defaultPrevented) {
    4902         return;
    4903       }
    4904 
    4905       const complete = () => {
    4906         this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
    4907 
    4908 
    4909         this._element.classList.remove(CLASS_NAME_SHOWING);
    4910 
    4911         this._element.classList.remove(CLASS_NAME_SHOW);
    4912 
    4913         EventHandler.trigger(this._element, EVENT_HIDDEN);
    4914       };
    4915 
    4916       this._element.classList.add(CLASS_NAME_SHOWING);
    4917 
    4918       this._queueCallback(complete, this._element, this._config.animation);
    4919     }
    4920 
    4921     dispose() {
    4922       this._clearTimeout();
    4923 
    4924       if (this._element.classList.contains(CLASS_NAME_SHOW)) {
    4925         this._element.classList.remove(CLASS_NAME_SHOW);
    4926       }
    4927 
    4928       super.dispose();
    4929     } // Private
    4930 
    4931 
    4932     _getConfig(config) {
    4933       config = { ...Default,
    4934         ...Manipulator.getDataAttributes(this._element),
    4935         ...(typeof config === 'object' && config ? config : {})
    4936       };
    4937       typeCheckConfig(NAME, config, this.constructor.DefaultType);
    4938       return config;
    4939     }
    4940 
    4941     _maybeScheduleHide() {
    4942       if (!this._config.autohide) {
    4943         return;
    4944       }
    4945 
    4946       if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
    4947         return;
    4948       }
    4949 
    4950       this._timeout = setTimeout(() => {
    4951         this.hide();
    4952       }, this._config.delay);
    4953     }
    4954 
    4955     _onInteraction(event, isInteracting) {
    4956       switch (event.type) {
    4957         case 'mouseover':
    4958         case 'mouseout':
    4959           this._hasMouseInteraction = isInteracting;
    4960           break;
    4961 
    4962         case 'focusin':
    4963         case 'focusout':
    4964           this._hasKeyboardInteraction = isInteracting;
    4965           break;
    4966       }
    4967 
    4968       if (isInteracting) {
    4969         this._clearTimeout();
    4970 
    4971         return;
    4972       }
    4973 
    4974       const nextElement = event.relatedTarget;
    4975 
    4976       if (this._element === nextElement || this._element.contains(nextElement)) {
    4977         return;
    4978       }
    4979 
    4980       this._maybeScheduleHide();
    4981     }
    4982 
    4983     _setListeners() {
    4984       EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
    4985       EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
    4986       EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
    4987       EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
    4988     }
    4989 
    4990     _clearTimeout() {
    4991       clearTimeout(this._timeout);
    4992       this._timeout = null;
    4993     } // Static
    4994 
    4995 
    4996     static jQueryInterface(config) {
    4997       return this.each(function () {
    4998         const data = Toast.getOrCreateInstance(this, config);
    4999 
    5000         if (typeof config === 'string') {
    5001           if (typeof data[config] === 'undefined') {
    5002             throw new TypeError(`No method named "${config}"`);
    5003           }
    5004 
    5005           data[config](this);
    5006         }
    5007       });
    5008     }
    5009 
    5010   }
    5011 
    5012   enableDismissTrigger(Toast);
    5013   /**
    5014    * ------------------------------------------------------------------------
    5015    * jQuery
    5016    * ------------------------------------------------------------------------
    5017    * add .Toast to jQuery only if jQuery is present
    5018    */
    5019 
    5020   defineJQueryPlugin(Toast);
    5021 
    5022   /**
    5023    * --------------------------------------------------------------------------
    5024    * Bootstrap (v5.1.3): index.umd.js
    5025    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    5026    * --------------------------------------------------------------------------
    5027    */
    5028   const index_umd = {
    5029     Alert,
    5030     Button,
    5031     Carousel,
    5032     Collapse,
    5033     Dropdown,
    5034     Modal,
    5035     Offcanvas,
    5036     Popover,
    5037     ScrollSpy,
    5038     Tab,
    5039     Toast,
    5040     Tooltip
    5041   };
    5042 
    5043   return index_umd;
    5044 
    5045 }));
    5046 //# sourceMappingURL=bootstrap.js.map
     2350        element.removeClass('fade')
     2351      }
     2352
     2353      if (element.parent('.dropdown-menu').length) {
     2354        element
     2355          .closest('li.dropdown')
     2356          .addClass('active')
     2357          .end()
     2358          .find('[data-toggle="tab"]')
     2359          .attr('aria-expanded', true)
     2360      }
     2361
     2362      callback && callback()
     2363    }
     2364
     2365    $active.length && transition ?
     2366      $active
     2367        .one('bsTransitionEnd', next)
     2368        .emulateTransitionEnd(Tab.TRANSITION_DURATION) :
     2369      next()
     2370
     2371    $active.removeClass('in')
     2372  }
     2373
     2374
     2375  // TAB PLUGIN DEFINITION
     2376  // =====================
     2377
     2378  function Plugin(option) {
     2379    return this.each(function () {
     2380      var $this = $(this)
     2381      var data  = $this.data('bs.tab')
     2382
     2383      if (!data) $this.data('bs.tab', (data = new Tab(this)))
     2384      if (typeof option == 'string') data[option]()
     2385    })
     2386  }
     2387
     2388  var old = $.fn.tab
     2389
     2390  $.fn.tab             = Plugin
     2391  $.fn.tab.Constructor = Tab
     2392
     2393
     2394  // TAB NO CONFLICT
     2395  // ===============
     2396
     2397  $.fn.tab.noConflict = function () {
     2398    $.fn.tab = old
     2399    return this
     2400  }
     2401
     2402
     2403  // TAB DATA-API
     2404  // ============
     2405
     2406  var clickHandler = function (e) {
     2407    e.preventDefault()
     2408    Plugin.call($(this), 'show')
     2409  }
     2410
     2411  $(document)
     2412    .on('click.bs.tab.data-api', '[data-toggle="tab"]', clickHandler)
     2413    .on('click.bs.tab.data-api', '[data-toggle="pill"]', clickHandler)
     2414
     2415}(jQuery);
     2416
     2417/* ========================================================================
     2418 * Bootstrap: affix.js v3.4.1
     2419 * https://getbootstrap.com/docs/3.4/javascript/#affix
     2420 * ========================================================================
     2421 * Copyright 2011-2019 Twitter, Inc.
     2422 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
     2423 * ======================================================================== */
     2424
     2425
     2426+function ($) {
     2427  'use strict';
     2428
     2429  // AFFIX CLASS DEFINITION
     2430  // ======================
     2431
     2432  var Affix = function (element, options) {
     2433    this.options = $.extend({}, Affix.DEFAULTS, options)
     2434
     2435    var target = this.options.target === Affix.DEFAULTS.target ? $(this.options.target) : $(document).find(this.options.target)
     2436
     2437    this.$target = target
     2438      .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
     2439      .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))
     2440
     2441    this.$element     = $(element)
     2442    this.affixed      = null
     2443    this.unpin        = null
     2444    this.pinnedOffset = null
     2445
     2446    this.checkPosition()
     2447  }
     2448
     2449  Affix.VERSION  = '3.4.1'
     2450
     2451  Affix.RESET    = 'affix affix-top affix-bottom'
     2452
     2453  Affix.DEFAULTS = {
     2454    offset: 0,
     2455    target: window
     2456  }
     2457
     2458  Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {
     2459    var scrollTop    = this.$target.scrollTop()
     2460    var position     = this.$element.offset()
     2461    var targetHeight = this.$target.height()
     2462
     2463    if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false
     2464
     2465    if (this.affixed == 'bottom') {
     2466      if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'
     2467      return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'
     2468    }
     2469
     2470    var initializing   = this.affixed == null
     2471    var colliderTop    = initializing ? scrollTop : position.top
     2472    var colliderHeight = initializing ? targetHeight : height
     2473
     2474    if (offsetTop != null && scrollTop <= offsetTop) return 'top'
     2475    if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'
     2476
     2477    return false
     2478  }
     2479
     2480  Affix.prototype.getPinnedOffset = function () {
     2481    if (this.pinnedOffset) return this.pinnedOffset
     2482    this.$element.removeClass(Affix.RESET).addClass('affix')
     2483    var scrollTop = this.$target.scrollTop()
     2484    var position  = this.$element.offset()
     2485    return (this.pinnedOffset = position.top - scrollTop)
     2486  }
     2487
     2488  Affix.prototype.checkPositionWithEventLoop = function () {
     2489    setTimeout($.proxy(this.checkPosition, this), 1)
     2490  }
     2491
     2492  Affix.prototype.checkPosition = function () {
     2493    if (!this.$element.is(':visible')) return
     2494
     2495    var height       = this.$element.height()
     2496    var offset       = this.options.offset
     2497    var offsetTop    = offset.top
     2498    var offsetBottom = offset.bottom
     2499    var scrollHeight = Math.max($(document).height(), $(document.body).height())
     2500
     2501    if (typeof offset != 'object')         offsetBottom = offsetTop = offset
     2502    if (typeof offsetTop == 'function')    offsetTop    = offset.top(this.$element)
     2503    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
     2504
     2505    var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)
     2506
     2507    if (this.affixed != affix) {
     2508      if (this.unpin != null) this.$element.css('top', '')
     2509
     2510      var affixType = 'affix' + (affix ? '-' + affix : '')
     2511      var e         = $.Event(affixType + '.bs.affix')
     2512
     2513      this.$element.trigger(e)
     2514
     2515      if (e.isDefaultPrevented()) return
     2516
     2517      this.affixed = affix
     2518      this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
     2519
     2520      this.$element
     2521        .removeClass(Affix.RESET)
     2522        .addClass(affixType)
     2523        .trigger(affixType.replace('affix', 'affixed') + '.bs.affix')
     2524    }
     2525
     2526    if (affix == 'bottom') {
     2527      this.$element.offset({
     2528        top: scrollHeight - height - offsetBottom
     2529      })
     2530    }
     2531  }
     2532
     2533
     2534  // AFFIX PLUGIN DEFINITION
     2535  // =======================
     2536
     2537  function Plugin(option) {
     2538    return this.each(function () {
     2539      var $this   = $(this)
     2540      var data    = $this.data('bs.affix')
     2541      var options = typeof option == 'object' && option
     2542
     2543      if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
     2544      if (typeof option == 'string') data[option]()
     2545    })
     2546  }
     2547
     2548  var old = $.fn.affix
     2549
     2550  $.fn.affix             = Plugin
     2551  $.fn.affix.Constructor = Affix
     2552
     2553
     2554  // AFFIX NO CONFLICT
     2555  // =================
     2556
     2557  $.fn.affix.noConflict = function () {
     2558    $.fn.affix = old
     2559    return this
     2560  }
     2561
     2562
     2563  // AFFIX DATA-API
     2564  // ==============
     2565
     2566  $(window).on('load', function () {
     2567    $('[data-spy="affix"]').each(function () {
     2568      var $spy = $(this)
     2569      var data = $spy.data()
     2570
     2571      data.offset = data.offset || {}
     2572
     2573      if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom
     2574      if (data.offsetTop    != null) data.offset.top    = data.offsetTop
     2575
     2576      Plugin.call($spy, data)
     2577    })
     2578  })
     2579
     2580}(jQuery);
  • trip-planner-front/node_modules/bootstrap/dist/js/bootstrap.min.js

    r6a3a178 rfa375fe  
    11/*!
    2   * Bootstrap v5.1.3 (https://getbootstrap.com/)
    3   * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
    4   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    5   */
    6 !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("@popperjs/core")):"function"==typeof define&&define.amd?define(["@popperjs/core"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).bootstrap=e(t.Popper)}(this,(function(t){"use strict";function e(t){if(t&&t.__esModule)return t;const e=Object.create(null);if(t)for(const i in t)if("default"!==i){const s=Object.getOwnPropertyDescriptor(t,i);Object.defineProperty(e,i,s.get?s:{enumerable:!0,get:()=>t[i]})}return e.default=t,Object.freeze(e)}const i=e(t),s="transitionend",n=t=>{let e=t.getAttribute("data-bs-target");if(!e||"#"===e){let i=t.getAttribute("href");if(!i||!i.includes("#")&&!i.startsWith("."))return null;i.includes("#")&&!i.startsWith("#")&&(i=`#${i.split("#")[1]}`),e=i&&"#"!==i?i.trim():null}return e},o=t=>{const e=n(t);return e&&document.querySelector(e)?e:null},r=t=>{const e=n(t);return e?document.querySelector(e):null},a=t=>{t.dispatchEvent(new Event(s))},l=t=>!(!t||"object"!=typeof t)&&(void 0!==t.jquery&&(t=t[0]),void 0!==t.nodeType),c=t=>l(t)?t.jquery?t[0]:t:"string"==typeof t&&t.length>0?document.querySelector(t):null,h=(t,e,i)=>{Object.keys(i).forEach((s=>{const n=i[s],o=e[s],r=o&&l(o)?"element":null==(a=o)?`${a}`:{}.toString.call(a).match(/\s([a-z]+)/i)[1].toLowerCase();var a;if(!new RegExp(n).test(r))throw new TypeError(`${t.toUpperCase()}: Option "${s}" provided type "${r}" but expected type "${n}".`)}))},d=t=>!(!l(t)||0===t.getClientRects().length)&&"visible"===getComputedStyle(t).getPropertyValue("visibility"),u=t=>!t||t.nodeType!==Node.ELEMENT_NODE||!!t.classList.contains("disabled")||(void 0!==t.disabled?t.disabled:t.hasAttribute("disabled")&&"false"!==t.getAttribute("disabled")),g=t=>{if(!document.documentElement.attachShadow)return null;if("function"==typeof t.getRootNode){const e=t.getRootNode();return e instanceof ShadowRoot?e:null}return t instanceof ShadowRoot?t:t.parentNode?g(t.parentNode):null},_=()=>{},f=t=>{t.offsetHeight},p=()=>{const{jQuery:t}=window;return t&&!document.body.hasAttribute("data-bs-no-jquery")?t:null},m=[],b=()=>"rtl"===document.documentElement.dir,v=t=>{var e;e=()=>{const e=p();if(e){const i=t.NAME,s=e.fn[i];e.fn[i]=t.jQueryInterface,e.fn[i].Constructor=t,e.fn[i].noConflict=()=>(e.fn[i]=s,t.jQueryInterface)}},"loading"===document.readyState?(m.length||document.addEventListener("DOMContentLoaded",(()=>{m.forEach((t=>t()))})),m.push(e)):e()},y=t=>{"function"==typeof t&&t()},E=(t,e,i=!0)=>{if(!i)return void y(t);const n=(t=>{if(!t)return 0;let{transitionDuration:e,transitionDelay:i}=window.getComputedStyle(t);const s=Number.parseFloat(e),n=Number.parseFloat(i);return s||n?(e=e.split(",")[0],i=i.split(",")[0],1e3*(Number.parseFloat(e)+Number.parseFloat(i))):0})(e)+5;let o=!1;const r=({target:i})=>{i===e&&(o=!0,e.removeEventListener(s,r),y(t))};e.addEventListener(s,r),setTimeout((()=>{o||a(e)}),n)},w=(t,e,i,s)=>{let n=t.indexOf(e);if(-1===n)return t[!i&&s?t.length-1:0];const o=t.length;return n+=i?1:-1,s&&(n=(n+o)%o),t[Math.max(0,Math.min(n,o-1))]},A=/[^.]*(?=\..*)\.|.*/,T=/\..*/,C=/::\d+$/,k={};let L=1;const S={mouseenter:"mouseover",mouseleave:"mouseout"},O=/^(mouseenter|mouseleave)/i,N=new Set(["click","dblclick","mouseup","mousedown","contextmenu","mousewheel","DOMMouseScroll","mouseover","mouseout","mousemove","selectstart","selectend","keydown","keypress","keyup","orientationchange","touchstart","touchmove","touchend","touchcancel","pointerdown","pointermove","pointerup","pointerleave","pointercancel","gesturestart","gesturechange","gestureend","focus","blur","change","reset","select","submit","focusin","focusout","load","unload","beforeunload","resize","move","DOMContentLoaded","readystatechange","error","abort","scroll"]);function D(t,e){return e&&`${e}::${L++}`||t.uidEvent||L++}function I(t){const e=D(t);return t.uidEvent=e,k[e]=k[e]||{},k[e]}function P(t,e,i=null){const s=Object.keys(t);for(let n=0,o=s.length;n<o;n++){const o=t[s[n]];if(o.originalHandler===e&&o.delegationSelector===i)return o}return null}function x(t,e,i){const s="string"==typeof e,n=s?i:e;let o=H(t);return N.has(o)||(o=t),[s,n,o]}function M(t,e,i,s,n){if("string"!=typeof e||!t)return;if(i||(i=s,s=null),O.test(e)){const t=t=>function(e){if(!e.relatedTarget||e.relatedTarget!==e.delegateTarget&&!e.delegateTarget.contains(e.relatedTarget))return t.call(this,e)};s?s=t(s):i=t(i)}const[o,r,a]=x(e,i,s),l=I(t),c=l[a]||(l[a]={}),h=P(c,r,o?i:null);if(h)return void(h.oneOff=h.oneOff&&n);const d=D(r,e.replace(A,"")),u=o?function(t,e,i){return function s(n){const o=t.querySelectorAll(e);for(let{target:r}=n;r&&r!==this;r=r.parentNode)for(let a=o.length;a--;)if(o[a]===r)return n.delegateTarget=r,s.oneOff&&$.off(t,n.type,e,i),i.apply(r,[n]);return null}}(t,i,s):function(t,e){return function i(s){return s.delegateTarget=t,i.oneOff&&$.off(t,s.type,e),e.apply(t,[s])}}(t,i);u.delegationSelector=o?i:null,u.originalHandler=r,u.oneOff=n,u.uidEvent=d,c[d]=u,t.addEventListener(a,u,o)}function j(t,e,i,s,n){const o=P(e[i],s,n);o&&(t.removeEventListener(i,o,Boolean(n)),delete e[i][o.uidEvent])}function H(t){return t=t.replace(T,""),S[t]||t}const $={on(t,e,i,s){M(t,e,i,s,!1)},one(t,e,i,s){M(t,e,i,s,!0)},off(t,e,i,s){if("string"!=typeof e||!t)return;const[n,o,r]=x(e,i,s),a=r!==e,l=I(t),c=e.startsWith(".");if(void 0!==o){if(!l||!l[r])return;return void j(t,l,r,o,n?i:null)}c&&Object.keys(l).forEach((i=>{!function(t,e,i,s){const n=e[i]||{};Object.keys(n).forEach((o=>{if(o.includes(s)){const s=n[o];j(t,e,i,s.originalHandler,s.delegationSelector)}}))}(t,l,i,e.slice(1))}));const h=l[r]||{};Object.keys(h).forEach((i=>{const s=i.replace(C,"");if(!a||e.includes(s)){const e=h[i];j(t,l,r,e.originalHandler,e.delegationSelector)}}))},trigger(t,e,i){if("string"!=typeof e||!t)return null;const s=p(),n=H(e),o=e!==n,r=N.has(n);let a,l=!0,c=!0,h=!1,d=null;return o&&s&&(a=s.Event(e,i),s(t).trigger(a),l=!a.isPropagationStopped(),c=!a.isImmediatePropagationStopped(),h=a.isDefaultPrevented()),r?(d=document.createEvent("HTMLEvents"),d.initEvent(n,l,!0)):d=new CustomEvent(e,{bubbles:l,cancelable:!0}),void 0!==i&&Object.keys(i).forEach((t=>{Object.defineProperty(d,t,{get:()=>i[t]})})),h&&d.preventDefault(),c&&t.dispatchEvent(d),d.defaultPrevented&&void 0!==a&&a.preventDefault(),d}},B=new Map,z={set(t,e,i){B.has(t)||B.set(t,new Map);const s=B.get(t);s.has(e)||0===s.size?s.set(e,i):console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(s.keys())[0]}.`)},get:(t,e)=>B.has(t)&&B.get(t).get(e)||null,remove(t,e){if(!B.has(t))return;const i=B.get(t);i.delete(e),0===i.size&&B.delete(t)}};class R{constructor(t){(t=c(t))&&(this._element=t,z.set(this._element,this.constructor.DATA_KEY,this))}dispose(){z.remove(this._element,this.constructor.DATA_KEY),$.off(this._element,this.constructor.EVENT_KEY),Object.getOwnPropertyNames(this).forEach((t=>{this[t]=null}))}_queueCallback(t,e,i=!0){E(t,e,i)}static getInstance(t){return z.get(c(t),this.DATA_KEY)}static getOrCreateInstance(t,e={}){return this.getInstance(t)||new this(t,"object"==typeof e?e:null)}static get VERSION(){return"5.1.3"}static get NAME(){throw new Error('You have to implement the static method "NAME", for each component!')}static get DATA_KEY(){return`bs.${this.NAME}`}static get EVENT_KEY(){return`.${this.DATA_KEY}`}}const F=(t,e="hide")=>{const i=`click.dismiss${t.EVENT_KEY}`,s=t.NAME;$.on(document,i,`[data-bs-dismiss="${s}"]`,(function(i){if(["A","AREA"].includes(this.tagName)&&i.preventDefault(),u(this))return;const n=r(this)||this.closest(`.${s}`);t.getOrCreateInstance(n)[e]()}))};class q extends R{static get NAME(){return"alert"}close(){if($.trigger(this._element,"close.bs.alert").defaultPrevented)return;this._element.classList.remove("show");const t=this._element.classList.contains("fade");this._queueCallback((()=>this._destroyElement()),this._element,t)}_destroyElement(){this._element.remove(),$.trigger(this._element,"closed.bs.alert"),this.dispose()}static jQueryInterface(t){return this.each((function(){const e=q.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}F(q,"close"),v(q);const W='[data-bs-toggle="button"]';class U extends R{static get NAME(){return"button"}toggle(){this._element.setAttribute("aria-pressed",this._element.classList.toggle("active"))}static jQueryInterface(t){return this.each((function(){const e=U.getOrCreateInstance(this);"toggle"===t&&e[t]()}))}}function K(t){return"true"===t||"false"!==t&&(t===Number(t).toString()?Number(t):""===t||"null"===t?null:t)}function V(t){return t.replace(/[A-Z]/g,(t=>`-${t.toLowerCase()}`))}$.on(document,"click.bs.button.data-api",W,(t=>{t.preventDefault();const e=t.target.closest(W);U.getOrCreateInstance(e).toggle()})),v(U);const X={setDataAttribute(t,e,i){t.setAttribute(`data-bs-${V(e)}`,i)},removeDataAttribute(t,e){t.removeAttribute(`data-bs-${V(e)}`)},getDataAttributes(t){if(!t)return{};const e={};return Object.keys(t.dataset).filter((t=>t.startsWith("bs"))).forEach((i=>{let s=i.replace(/^bs/,"");s=s.charAt(0).toLowerCase()+s.slice(1,s.length),e[s]=K(t.dataset[i])})),e},getDataAttribute:(t,e)=>K(t.getAttribute(`data-bs-${V(e)}`)),offset(t){const e=t.getBoundingClientRect();return{top:e.top+window.pageYOffset,left:e.left+window.pageXOffset}},position:t=>({top:t.offsetTop,left:t.offsetLeft})},Y={find:(t,e=document.documentElement)=>[].concat(...Element.prototype.querySelectorAll.call(e,t)),findOne:(t,e=document.documentElement)=>Element.prototype.querySelector.call(e,t),children:(t,e)=>[].concat(...t.children).filter((t=>t.matches(e))),parents(t,e){const i=[];let s=t.parentNode;for(;s&&s.nodeType===Node.ELEMENT_NODE&&3!==s.nodeType;)s.matches(e)&&i.push(s),s=s.parentNode;return i},prev(t,e){let i=t.previousElementSibling;for(;i;){if(i.matches(e))return[i];i=i.previousElementSibling}return[]},next(t,e){let i=t.nextElementSibling;for(;i;){if(i.matches(e))return[i];i=i.nextElementSibling}return[]},focusableChildren(t){const e=["a","button","input","textarea","select","details","[tabindex]",'[contenteditable="true"]'].map((t=>`${t}:not([tabindex^="-"])`)).join(", ");return this.find(e,t).filter((t=>!u(t)&&d(t)))}},Q="carousel",G={interval:5e3,keyboard:!0,slide:!1,pause:"hover",wrap:!0,touch:!0},Z={interval:"(number|boolean)",keyboard:"boolean",slide:"(boolean|string)",pause:"(string|boolean)",wrap:"boolean",touch:"boolean"},J="next",tt="prev",et="left",it="right",st={ArrowLeft:it,ArrowRight:et},nt="slid.bs.carousel",ot="active",rt=".active.carousel-item";class at extends R{constructor(t,e){super(t),this._items=null,this._interval=null,this._activeElement=null,this._isPaused=!1,this._isSliding=!1,this.touchTimeout=null,this.touchStartX=0,this.touchDeltaX=0,this._config=this._getConfig(e),this._indicatorsElement=Y.findOne(".carousel-indicators",this._element),this._touchSupported="ontouchstart"in document.documentElement||navigator.maxTouchPoints>0,this._pointerEvent=Boolean(window.PointerEvent),this._addEventListeners()}static get Default(){return G}static get NAME(){return Q}next(){this._slide(J)}nextWhenVisible(){!document.hidden&&d(this._element)&&this.next()}prev(){this._slide(tt)}pause(t){t||(this._isPaused=!0),Y.findOne(".carousel-item-next, .carousel-item-prev",this._element)&&(a(this._element),this.cycle(!0)),clearInterval(this._interval),this._interval=null}cycle(t){t||(this._isPaused=!1),this._interval&&(clearInterval(this._interval),this._interval=null),this._config&&this._config.interval&&!this._isPaused&&(this._updateInterval(),this._interval=setInterval((document.visibilityState?this.nextWhenVisible:this.next).bind(this),this._config.interval))}to(t){this._activeElement=Y.findOne(rt,this._element);const e=this._getItemIndex(this._activeElement);if(t>this._items.length-1||t<0)return;if(this._isSliding)return void $.one(this._element,nt,(()=>this.to(t)));if(e===t)return this.pause(),void this.cycle();const i=t>e?J:tt;this._slide(i,this._items[t])}_getConfig(t){return t={...G,...X.getDataAttributes(this._element),..."object"==typeof t?t:{}},h(Q,t,Z),t}_handleSwipe(){const t=Math.abs(this.touchDeltaX);if(t<=40)return;const e=t/this.touchDeltaX;this.touchDeltaX=0,e&&this._slide(e>0?it:et)}_addEventListeners(){this._config.keyboard&&$.on(this._element,"keydown.bs.carousel",(t=>this._keydown(t))),"hover"===this._config.pause&&($.on(this._element,"mouseenter.bs.carousel",(t=>this.pause(t))),$.on(this._element,"mouseleave.bs.carousel",(t=>this.cycle(t)))),this._config.touch&&this._touchSupported&&this._addTouchEventListeners()}_addTouchEventListeners(){const t=t=>this._pointerEvent&&("pen"===t.pointerType||"touch"===t.pointerType),e=e=>{t(e)?this.touchStartX=e.clientX:this._pointerEvent||(this.touchStartX=e.touches[0].clientX)},i=t=>{this.touchDeltaX=t.touches&&t.touches.length>1?0:t.touches[0].clientX-this.touchStartX},s=e=>{t(e)&&(this.touchDeltaX=e.clientX-this.touchStartX),this._handleSwipe(),"hover"===this._config.pause&&(this.pause(),this.touchTimeout&&clearTimeout(this.touchTimeout),this.touchTimeout=setTimeout((t=>this.cycle(t)),500+this._config.interval))};Y.find(".carousel-item img",this._element).forEach((t=>{$.on(t,"dragstart.bs.carousel",(t=>t.preventDefault()))})),this._pointerEvent?($.on(this._element,"pointerdown.bs.carousel",(t=>e(t))),$.on(this._element,"pointerup.bs.carousel",(t=>s(t))),this._element.classList.add("pointer-event")):($.on(this._element,"touchstart.bs.carousel",(t=>e(t))),$.on(this._element,"touchmove.bs.carousel",(t=>i(t))),$.on(this._element,"touchend.bs.carousel",(t=>s(t))))}_keydown(t){if(/input|textarea/i.test(t.target.tagName))return;const e=st[t.key];e&&(t.preventDefault(),this._slide(e))}_getItemIndex(t){return this._items=t&&t.parentNode?Y.find(".carousel-item",t.parentNode):[],this._items.indexOf(t)}_getItemByOrder(t,e){const i=t===J;return w(this._items,e,i,this._config.wrap)}_triggerSlideEvent(t,e){const i=this._getItemIndex(t),s=this._getItemIndex(Y.findOne(rt,this._element));return $.trigger(this._element,"slide.bs.carousel",{relatedTarget:t,direction:e,from:s,to:i})}_setActiveIndicatorElement(t){if(this._indicatorsElement){const e=Y.findOne(".active",this._indicatorsElement);e.classList.remove(ot),e.removeAttribute("aria-current");const i=Y.find("[data-bs-target]",this._indicatorsElement);for(let e=0;e<i.length;e++)if(Number.parseInt(i[e].getAttribute("data-bs-slide-to"),10)===this._getItemIndex(t)){i[e].classList.add(ot),i[e].setAttribute("aria-current","true");break}}}_updateInterval(){const t=this._activeElement||Y.findOne(rt,this._element);if(!t)return;const e=Number.parseInt(t.getAttribute("data-bs-interval"),10);e?(this._config.defaultInterval=this._config.defaultInterval||this._config.interval,this._config.interval=e):this._config.interval=this._config.defaultInterval||this._config.interval}_slide(t,e){const i=this._directionToOrder(t),s=Y.findOne(rt,this._element),n=this._getItemIndex(s),o=e||this._getItemByOrder(i,s),r=this._getItemIndex(o),a=Boolean(this._interval),l=i===J,c=l?"carousel-item-start":"carousel-item-end",h=l?"carousel-item-next":"carousel-item-prev",d=this._orderToDirection(i);if(o&&o.classList.contains(ot))return void(this._isSliding=!1);if(this._isSliding)return;if(this._triggerSlideEvent(o,d).defaultPrevented)return;if(!s||!o)return;this._isSliding=!0,a&&this.pause(),this._setActiveIndicatorElement(o),this._activeElement=o;const u=()=>{$.trigger(this._element,nt,{relatedTarget:o,direction:d,from:n,to:r})};if(this._element.classList.contains("slide")){o.classList.add(h),f(o),s.classList.add(c),o.classList.add(c);const t=()=>{o.classList.remove(c,h),o.classList.add(ot),s.classList.remove(ot,h,c),this._isSliding=!1,setTimeout(u,0)};this._queueCallback(t,s,!0)}else s.classList.remove(ot),o.classList.add(ot),this._isSliding=!1,u();a&&this.cycle()}_directionToOrder(t){return[it,et].includes(t)?b()?t===et?tt:J:t===et?J:tt:t}_orderToDirection(t){return[J,tt].includes(t)?b()?t===tt?et:it:t===tt?it:et:t}static carouselInterface(t,e){const i=at.getOrCreateInstance(t,e);let{_config:s}=i;"object"==typeof e&&(s={...s,...e});const n="string"==typeof e?e:s.slide;if("number"==typeof e)i.to(e);else if("string"==typeof n){if(void 0===i[n])throw new TypeError(`No method named "${n}"`);i[n]()}else s.interval&&s.ride&&(i.pause(),i.cycle())}static jQueryInterface(t){return this.each((function(){at.carouselInterface(this,t)}))}static dataApiClickHandler(t){const e=r(this);if(!e||!e.classList.contains("carousel"))return;const i={...X.getDataAttributes(e),...X.getDataAttributes(this)},s=this.getAttribute("data-bs-slide-to");s&&(i.interval=!1),at.carouselInterface(e,i),s&&at.getInstance(e).to(s),t.preventDefault()}}$.on(document,"click.bs.carousel.data-api","[data-bs-slide], [data-bs-slide-to]",at.dataApiClickHandler),$.on(window,"load.bs.carousel.data-api",(()=>{const t=Y.find('[data-bs-ride="carousel"]');for(let e=0,i=t.length;e<i;e++)at.carouselInterface(t[e],at.getInstance(t[e]))})),v(at);const lt="collapse",ct={toggle:!0,parent:null},ht={toggle:"boolean",parent:"(null|element)"},dt="show",ut="collapse",gt="collapsing",_t="collapsed",ft=":scope .collapse .collapse",pt='[data-bs-toggle="collapse"]';class mt extends R{constructor(t,e){super(t),this._isTransitioning=!1,this._config=this._getConfig(e),this._triggerArray=[];const i=Y.find(pt);for(let t=0,e=i.length;t<e;t++){const e=i[t],s=o(e),n=Y.find(s).filter((t=>t===this._element));null!==s&&n.length&&(this._selector=s,this._triggerArray.push(e))}this._initializeChildren(),this._config.parent||this._addAriaAndCollapsedClass(this._triggerArray,this._isShown()),this._config.toggle&&this.toggle()}static get Default(){return ct}static get NAME(){return lt}toggle(){this._isShown()?this.hide():this.show()}show(){if(this._isTransitioning||this._isShown())return;let t,e=[];if(this._config.parent){const t=Y.find(ft,this._config.parent);e=Y.find(".collapse.show, .collapse.collapsing",this._config.parent).filter((e=>!t.includes(e)))}const i=Y.findOne(this._selector);if(e.length){const s=e.find((t=>i!==t));if(t=s?mt.getInstance(s):null,t&&t._isTransitioning)return}if($.trigger(this._element,"show.bs.collapse").defaultPrevented)return;e.forEach((e=>{i!==e&&mt.getOrCreateInstance(e,{toggle:!1}).hide(),t||z.set(e,"bs.collapse",null)}));const s=this._getDimension();this._element.classList.remove(ut),this._element.classList.add(gt),this._element.style[s]=0,this._addAriaAndCollapsedClass(this._triggerArray,!0),this._isTransitioning=!0;const n=`scroll${s[0].toUpperCase()+s.slice(1)}`;this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(gt),this._element.classList.add(ut,dt),this._element.style[s]="",$.trigger(this._element,"shown.bs.collapse")}),this._element,!0),this._element.style[s]=`${this._element[n]}px`}hide(){if(this._isTransitioning||!this._isShown())return;if($.trigger(this._element,"hide.bs.collapse").defaultPrevented)return;const t=this._getDimension();this._element.style[t]=`${this._element.getBoundingClientRect()[t]}px`,f(this._element),this._element.classList.add(gt),this._element.classList.remove(ut,dt);const e=this._triggerArray.length;for(let t=0;t<e;t++){const e=this._triggerArray[t],i=r(e);i&&!this._isShown(i)&&this._addAriaAndCollapsedClass([e],!1)}this._isTransitioning=!0,this._element.style[t]="",this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(gt),this._element.classList.add(ut),$.trigger(this._element,"hidden.bs.collapse")}),this._element,!0)}_isShown(t=this._element){return t.classList.contains(dt)}_getConfig(t){return(t={...ct,...X.getDataAttributes(this._element),...t}).toggle=Boolean(t.toggle),t.parent=c(t.parent),h(lt,t,ht),t}_getDimension(){return this._element.classList.contains("collapse-horizontal")?"width":"height"}_initializeChildren(){if(!this._config.parent)return;const t=Y.find(ft,this._config.parent);Y.find(pt,this._config.parent).filter((e=>!t.includes(e))).forEach((t=>{const e=r(t);e&&this._addAriaAndCollapsedClass([t],this._isShown(e))}))}_addAriaAndCollapsedClass(t,e){t.length&&t.forEach((t=>{e?t.classList.remove(_t):t.classList.add(_t),t.setAttribute("aria-expanded",e)}))}static jQueryInterface(t){return this.each((function(){const e={};"string"==typeof t&&/show|hide/.test(t)&&(e.toggle=!1);const i=mt.getOrCreateInstance(this,e);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t]()}}))}}$.on(document,"click.bs.collapse.data-api",pt,(function(t){("A"===t.target.tagName||t.delegateTarget&&"A"===t.delegateTarget.tagName)&&t.preventDefault();const e=o(this);Y.find(e).forEach((t=>{mt.getOrCreateInstance(t,{toggle:!1}).toggle()}))})),v(mt);const bt="dropdown",vt="Escape",yt="Space",Et="ArrowUp",wt="ArrowDown",At=new RegExp("ArrowUp|ArrowDown|Escape"),Tt="click.bs.dropdown.data-api",Ct="keydown.bs.dropdown.data-api",kt="show",Lt='[data-bs-toggle="dropdown"]',St=".dropdown-menu",Ot=b()?"top-end":"top-start",Nt=b()?"top-start":"top-end",Dt=b()?"bottom-end":"bottom-start",It=b()?"bottom-start":"bottom-end",Pt=b()?"left-start":"right-start",xt=b()?"right-start":"left-start",Mt={offset:[0,2],boundary:"clippingParents",reference:"toggle",display:"dynamic",popperConfig:null,autoClose:!0},jt={offset:"(array|string|function)",boundary:"(string|element)",reference:"(string|element|object)",display:"string",popperConfig:"(null|object|function)",autoClose:"(boolean|string)"};class Ht extends R{constructor(t,e){super(t),this._popper=null,this._config=this._getConfig(e),this._menu=this._getMenuElement(),this._inNavbar=this._detectNavbar()}static get Default(){return Mt}static get DefaultType(){return jt}static get NAME(){return bt}toggle(){return this._isShown()?this.hide():this.show()}show(){if(u(this._element)||this._isShown(this._menu))return;const t={relatedTarget:this._element};if($.trigger(this._element,"show.bs.dropdown",t).defaultPrevented)return;const e=Ht.getParentFromElement(this._element);this._inNavbar?X.setDataAttribute(this._menu,"popper","none"):this._createPopper(e),"ontouchstart"in document.documentElement&&!e.closest(".navbar-nav")&&[].concat(...document.body.children).forEach((t=>$.on(t,"mouseover",_))),this._element.focus(),this._element.setAttribute("aria-expanded",!0),this._menu.classList.add(kt),this._element.classList.add(kt),$.trigger(this._element,"shown.bs.dropdown",t)}hide(){if(u(this._element)||!this._isShown(this._menu))return;const t={relatedTarget:this._element};this._completeHide(t)}dispose(){this._popper&&this._popper.destroy(),super.dispose()}update(){this._inNavbar=this._detectNavbar(),this._popper&&this._popper.update()}_completeHide(t){$.trigger(this._element,"hide.bs.dropdown",t).defaultPrevented||("ontouchstart"in document.documentElement&&[].concat(...document.body.children).forEach((t=>$.off(t,"mouseover",_))),this._popper&&this._popper.destroy(),this._menu.classList.remove(kt),this._element.classList.remove(kt),this._element.setAttribute("aria-expanded","false"),X.removeDataAttribute(this._menu,"popper"),$.trigger(this._element,"hidden.bs.dropdown",t))}_getConfig(t){if(t={...this.constructor.Default,...X.getDataAttributes(this._element),...t},h(bt,t,this.constructor.DefaultType),"object"==typeof t.reference&&!l(t.reference)&&"function"!=typeof t.reference.getBoundingClientRect)throw new TypeError(`${bt.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);return t}_createPopper(t){if(void 0===i)throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");let e=this._element;"parent"===this._config.reference?e=t:l(this._config.reference)?e=c(this._config.reference):"object"==typeof this._config.reference&&(e=this._config.reference);const s=this._getPopperConfig(),n=s.modifiers.find((t=>"applyStyles"===t.name&&!1===t.enabled));this._popper=i.createPopper(e,this._menu,s),n&&X.setDataAttribute(this._menu,"popper","static")}_isShown(t=this._element){return t.classList.contains(kt)}_getMenuElement(){return Y.next(this._element,St)[0]}_getPlacement(){const t=this._element.parentNode;if(t.classList.contains("dropend"))return Pt;if(t.classList.contains("dropstart"))return xt;const e="end"===getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();return t.classList.contains("dropup")?e?Nt:Ot:e?It:Dt}_detectNavbar(){return null!==this._element.closest(".navbar")}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_getPopperConfig(){const t={placement:this._getPlacement(),modifiers:[{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"offset",options:{offset:this._getOffset()}}]};return"static"===this._config.display&&(t.modifiers=[{name:"applyStyles",enabled:!1}]),{...t,..."function"==typeof this._config.popperConfig?this._config.popperConfig(t):this._config.popperConfig}}_selectMenuItem({key:t,target:e}){const i=Y.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",this._menu).filter(d);i.length&&w(i,e,t===wt,!i.includes(e)).focus()}static jQueryInterface(t){return this.each((function(){const e=Ht.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}static clearMenus(t){if(t&&(2===t.button||"keyup"===t.type&&"Tab"!==t.key))return;const e=Y.find(Lt);for(let i=0,s=e.length;i<s;i++){const s=Ht.getInstance(e[i]);if(!s||!1===s._config.autoClose)continue;if(!s._isShown())continue;const n={relatedTarget:s._element};if(t){const e=t.composedPath(),i=e.includes(s._menu);if(e.includes(s._element)||"inside"===s._config.autoClose&&!i||"outside"===s._config.autoClose&&i)continue;if(s._menu.contains(t.target)&&("keyup"===t.type&&"Tab"===t.key||/input|select|option|textarea|form/i.test(t.target.tagName)))continue;"click"===t.type&&(n.clickEvent=t)}s._completeHide(n)}}static getParentFromElement(t){return r(t)||t.parentNode}static dataApiKeydownHandler(t){if(/input|textarea/i.test(t.target.tagName)?t.key===yt||t.key!==vt&&(t.key!==wt&&t.key!==Et||t.target.closest(St)):!At.test(t.key))return;const e=this.classList.contains(kt);if(!e&&t.key===vt)return;if(t.preventDefault(),t.stopPropagation(),u(this))return;const i=this.matches(Lt)?this:Y.prev(this,Lt)[0],s=Ht.getOrCreateInstance(i);if(t.key!==vt)return t.key===Et||t.key===wt?(e||s.show(),void s._selectMenuItem(t)):void(e&&t.key!==yt||Ht.clearMenus());s.hide()}}$.on(document,Ct,Lt,Ht.dataApiKeydownHandler),$.on(document,Ct,St,Ht.dataApiKeydownHandler),$.on(document,Tt,Ht.clearMenus),$.on(document,"keyup.bs.dropdown.data-api",Ht.clearMenus),$.on(document,Tt,Lt,(function(t){t.preventDefault(),Ht.getOrCreateInstance(this).toggle()})),v(Ht);const $t=".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",Bt=".sticky-top";class zt{constructor(){this._element=document.body}getWidth(){const t=document.documentElement.clientWidth;return Math.abs(window.innerWidth-t)}hide(){const t=this.getWidth();this._disableOverFlow(),this._setElementAttributes(this._element,"paddingRight",(e=>e+t)),this._setElementAttributes($t,"paddingRight",(e=>e+t)),this._setElementAttributes(Bt,"marginRight",(e=>e-t))}_disableOverFlow(){this._saveInitialAttribute(this._element,"overflow"),this._element.style.overflow="hidden"}_setElementAttributes(t,e,i){const s=this.getWidth();this._applyManipulationCallback(t,(t=>{if(t!==this._element&&window.innerWidth>t.clientWidth+s)return;this._saveInitialAttribute(t,e);const n=window.getComputedStyle(t)[e];t.style[e]=`${i(Number.parseFloat(n))}px`}))}reset(){this._resetElementAttributes(this._element,"overflow"),this._resetElementAttributes(this._element,"paddingRight"),this._resetElementAttributes($t,"paddingRight"),this._resetElementAttributes(Bt,"marginRight")}_saveInitialAttribute(t,e){const i=t.style[e];i&&X.setDataAttribute(t,e,i)}_resetElementAttributes(t,e){this._applyManipulationCallback(t,(t=>{const i=X.getDataAttribute(t,e);void 0===i?t.style.removeProperty(e):(X.removeDataAttribute(t,e),t.style[e]=i)}))}_applyManipulationCallback(t,e){l(t)?e(t):Y.find(t,this._element).forEach(e)}isOverflowing(){return this.getWidth()>0}}const Rt={className:"modal-backdrop",isVisible:!0,isAnimated:!1,rootElement:"body",clickCallback:null},Ft={className:"string",isVisible:"boolean",isAnimated:"boolean",rootElement:"(element|string)",clickCallback:"(function|null)"},qt="show",Wt="mousedown.bs.backdrop";class Ut{constructor(t){this._config=this._getConfig(t),this._isAppended=!1,this._element=null}show(t){this._config.isVisible?(this._append(),this._config.isAnimated&&f(this._getElement()),this._getElement().classList.add(qt),this._emulateAnimation((()=>{y(t)}))):y(t)}hide(t){this._config.isVisible?(this._getElement().classList.remove(qt),this._emulateAnimation((()=>{this.dispose(),y(t)}))):y(t)}_getElement(){if(!this._element){const t=document.createElement("div");t.className=this._config.className,this._config.isAnimated&&t.classList.add("fade"),this._element=t}return this._element}_getConfig(t){return(t={...Rt,..."object"==typeof t?t:{}}).rootElement=c(t.rootElement),h("backdrop",t,Ft),t}_append(){this._isAppended||(this._config.rootElement.append(this._getElement()),$.on(this._getElement(),Wt,(()=>{y(this._config.clickCallback)})),this._isAppended=!0)}dispose(){this._isAppended&&($.off(this._element,Wt),this._element.remove(),this._isAppended=!1)}_emulateAnimation(t){E(t,this._getElement(),this._config.isAnimated)}}const Kt={trapElement:null,autofocus:!0},Vt={trapElement:"element",autofocus:"boolean"},Xt=".bs.focustrap",Yt="backward";class Qt{constructor(t){this._config=this._getConfig(t),this._isActive=!1,this._lastTabNavDirection=null}activate(){const{trapElement:t,autofocus:e}=this._config;this._isActive||(e&&t.focus(),$.off(document,Xt),$.on(document,"focusin.bs.focustrap",(t=>this._handleFocusin(t))),$.on(document,"keydown.tab.bs.focustrap",(t=>this._handleKeydown(t))),this._isActive=!0)}deactivate(){this._isActive&&(this._isActive=!1,$.off(document,Xt))}_handleFocusin(t){const{target:e}=t,{trapElement:i}=this._config;if(e===document||e===i||i.contains(e))return;const s=Y.focusableChildren(i);0===s.length?i.focus():this._lastTabNavDirection===Yt?s[s.length-1].focus():s[0].focus()}_handleKeydown(t){"Tab"===t.key&&(this._lastTabNavDirection=t.shiftKey?Yt:"forward")}_getConfig(t){return t={...Kt,..."object"==typeof t?t:{}},h("focustrap",t,Vt),t}}const Gt="modal",Zt="Escape",Jt={backdrop:!0,keyboard:!0,focus:!0},te={backdrop:"(boolean|string)",keyboard:"boolean",focus:"boolean"},ee="hidden.bs.modal",ie="show.bs.modal",se="resize.bs.modal",ne="click.dismiss.bs.modal",oe="keydown.dismiss.bs.modal",re="mousedown.dismiss.bs.modal",ae="modal-open",le="show",ce="modal-static";class he extends R{constructor(t,e){super(t),this._config=this._getConfig(e),this._dialog=Y.findOne(".modal-dialog",this._element),this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._isShown=!1,this._ignoreBackdropClick=!1,this._isTransitioning=!1,this._scrollBar=new zt}static get Default(){return Jt}static get NAME(){return Gt}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||this._isTransitioning||$.trigger(this._element,ie,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._isAnimated()&&(this._isTransitioning=!0),this._scrollBar.hide(),document.body.classList.add(ae),this._adjustDialog(),this._setEscapeEvent(),this._setResizeEvent(),$.on(this._dialog,re,(()=>{$.one(this._element,"mouseup.dismiss.bs.modal",(t=>{t.target===this._element&&(this._ignoreBackdropClick=!0)}))})),this._showBackdrop((()=>this._showElement(t))))}hide(){if(!this._isShown||this._isTransitioning)return;if($.trigger(this._element,"hide.bs.modal").defaultPrevented)return;this._isShown=!1;const t=this._isAnimated();t&&(this._isTransitioning=!0),this._setEscapeEvent(),this._setResizeEvent(),this._focustrap.deactivate(),this._element.classList.remove(le),$.off(this._element,ne),$.off(this._dialog,re),this._queueCallback((()=>this._hideModal()),this._element,t)}dispose(){[window,this._dialog].forEach((t=>$.off(t,".bs.modal"))),this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}handleUpdate(){this._adjustDialog()}_initializeBackDrop(){return new Ut({isVisible:Boolean(this._config.backdrop),isAnimated:this._isAnimated()})}_initializeFocusTrap(){return new Qt({trapElement:this._element})}_getConfig(t){return t={...Jt,...X.getDataAttributes(this._element),..."object"==typeof t?t:{}},h(Gt,t,te),t}_showElement(t){const e=this._isAnimated(),i=Y.findOne(".modal-body",this._dialog);this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE||document.body.append(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.scrollTop=0,i&&(i.scrollTop=0),e&&f(this._element),this._element.classList.add(le),this._queueCallback((()=>{this._config.focus&&this._focustrap.activate(),this._isTransitioning=!1,$.trigger(this._element,"shown.bs.modal",{relatedTarget:t})}),this._dialog,e)}_setEscapeEvent(){this._isShown?$.on(this._element,oe,(t=>{this._config.keyboard&&t.key===Zt?(t.preventDefault(),this.hide()):this._config.keyboard||t.key!==Zt||this._triggerBackdropTransition()})):$.off(this._element,oe)}_setResizeEvent(){this._isShown?$.on(window,se,(()=>this._adjustDialog())):$.off(window,se)}_hideModal(){this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._isTransitioning=!1,this._backdrop.hide((()=>{document.body.classList.remove(ae),this._resetAdjustments(),this._scrollBar.reset(),$.trigger(this._element,ee)}))}_showBackdrop(t){$.on(this._element,ne,(t=>{this._ignoreBackdropClick?this._ignoreBackdropClick=!1:t.target===t.currentTarget&&(!0===this._config.backdrop?this.hide():"static"===this._config.backdrop&&this._triggerBackdropTransition())})),this._backdrop.show(t)}_isAnimated(){return this._element.classList.contains("fade")}_triggerBackdropTransition(){if($.trigger(this._element,"hidePrevented.bs.modal").defaultPrevented)return;const{classList:t,scrollHeight:e,style:i}=this._element,s=e>document.documentElement.clientHeight;!s&&"hidden"===i.overflowY||t.contains(ce)||(s||(i.overflowY="hidden"),t.add(ce),this._queueCallback((()=>{t.remove(ce),s||this._queueCallback((()=>{i.overflowY=""}),this._dialog)}),this._dialog),this._element.focus())}_adjustDialog(){const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._scrollBar.getWidth(),i=e>0;(!i&&t&&!b()||i&&!t&&b())&&(this._element.style.paddingLeft=`${e}px`),(i&&!t&&!b()||!i&&t&&b())&&(this._element.style.paddingRight=`${e}px`)}_resetAdjustments(){this._element.style.paddingLeft="",this._element.style.paddingRight=""}static jQueryInterface(t,e){return this.each((function(){const i=he.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t](e)}}))}}$.on(document,"click.bs.modal.data-api",'[data-bs-toggle="modal"]',(function(t){const e=r(this);["A","AREA"].includes(this.tagName)&&t.preventDefault(),$.one(e,ie,(t=>{t.defaultPrevented||$.one(e,ee,(()=>{d(this)&&this.focus()}))}));const i=Y.findOne(".modal.show");i&&he.getInstance(i).hide(),he.getOrCreateInstance(e).toggle(this)})),F(he),v(he);const de="offcanvas",ue={backdrop:!0,keyboard:!0,scroll:!1},ge={backdrop:"boolean",keyboard:"boolean",scroll:"boolean"},_e="show",fe=".offcanvas.show",pe="hidden.bs.offcanvas";class me extends R{constructor(t,e){super(t),this._config=this._getConfig(e),this._isShown=!1,this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._addEventListeners()}static get NAME(){return de}static get Default(){return ue}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||$.trigger(this._element,"show.bs.offcanvas",{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._element.style.visibility="visible",this._backdrop.show(),this._config.scroll||(new zt).hide(),this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.classList.add(_e),this._queueCallback((()=>{this._config.scroll||this._focustrap.activate(),$.trigger(this._element,"shown.bs.offcanvas",{relatedTarget:t})}),this._element,!0))}hide(){this._isShown&&($.trigger(this._element,"hide.bs.offcanvas").defaultPrevented||(this._focustrap.deactivate(),this._element.blur(),this._isShown=!1,this._element.classList.remove(_e),this._backdrop.hide(),this._queueCallback((()=>{this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._element.style.visibility="hidden",this._config.scroll||(new zt).reset(),$.trigger(this._element,pe)}),this._element,!0)))}dispose(){this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}_getConfig(t){return t={...ue,...X.getDataAttributes(this._element),..."object"==typeof t?t:{}},h(de,t,ge),t}_initializeBackDrop(){return new Ut({className:"offcanvas-backdrop",isVisible:this._config.backdrop,isAnimated:!0,rootElement:this._element.parentNode,clickCallback:()=>this.hide()})}_initializeFocusTrap(){return new Qt({trapElement:this._element})}_addEventListeners(){$.on(this._element,"keydown.dismiss.bs.offcanvas",(t=>{this._config.keyboard&&"Escape"===t.key&&this.hide()}))}static jQueryInterface(t){return this.each((function(){const e=me.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}$.on(document,"click.bs.offcanvas.data-api",'[data-bs-toggle="offcanvas"]',(function(t){const e=r(this);if(["A","AREA"].includes(this.tagName)&&t.preventDefault(),u(this))return;$.one(e,pe,(()=>{d(this)&&this.focus()}));const i=Y.findOne(fe);i&&i!==e&&me.getInstance(i).hide(),me.getOrCreateInstance(e).toggle(this)})),$.on(window,"load.bs.offcanvas.data-api",(()=>Y.find(fe).forEach((t=>me.getOrCreateInstance(t).show())))),F(me),v(me);const be=new Set(["background","cite","href","itemtype","longdesc","poster","src","xlink:href"]),ve=/^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i,ye=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i,Ee=(t,e)=>{const i=t.nodeName.toLowerCase();if(e.includes(i))return!be.has(i)||Boolean(ve.test(t.nodeValue)||ye.test(t.nodeValue));const s=e.filter((t=>t instanceof RegExp));for(let t=0,e=s.length;t<e;t++)if(s[t].test(i))return!0;return!1};function we(t,e,i){if(!t.length)return t;if(i&&"function"==typeof i)return i(t);const s=(new window.DOMParser).parseFromString(t,"text/html"),n=[].concat(...s.body.querySelectorAll("*"));for(let t=0,i=n.length;t<i;t++){const i=n[t],s=i.nodeName.toLowerCase();if(!Object.keys(e).includes(s)){i.remove();continue}const o=[].concat(...i.attributes),r=[].concat(e["*"]||[],e[s]||[]);o.forEach((t=>{Ee(t,r)||i.removeAttribute(t.nodeName)}))}return s.body.innerHTML}const Ae="tooltip",Te=new Set(["sanitize","allowList","sanitizeFn"]),Ce={animation:"boolean",template:"string",title:"(string|element|function)",trigger:"string",delay:"(number|object)",html:"boolean",selector:"(string|boolean)",placement:"(string|function)",offset:"(array|string|function)",container:"(string|element|boolean)",fallbackPlacements:"array",boundary:"(string|element)",customClass:"(string|function)",sanitize:"boolean",sanitizeFn:"(null|function)",allowList:"object",popperConfig:"(null|object|function)"},ke={AUTO:"auto",TOP:"top",RIGHT:b()?"left":"right",BOTTOM:"bottom",LEFT:b()?"right":"left"},Le={animation:!0,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,selector:!1,placement:"top",offset:[0,0],container:!1,fallbackPlacements:["top","right","bottom","left"],boundary:"clippingParents",customClass:"",sanitize:!0,sanitizeFn:null,allowList:{"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","srcset","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},popperConfig:null},Se={HIDE:"hide.bs.tooltip",HIDDEN:"hidden.bs.tooltip",SHOW:"show.bs.tooltip",SHOWN:"shown.bs.tooltip",INSERTED:"inserted.bs.tooltip",CLICK:"click.bs.tooltip",FOCUSIN:"focusin.bs.tooltip",FOCUSOUT:"focusout.bs.tooltip",MOUSEENTER:"mouseenter.bs.tooltip",MOUSELEAVE:"mouseleave.bs.tooltip"},Oe="fade",Ne="show",De="show",Ie="out",Pe=".tooltip-inner",xe=".modal",Me="hide.bs.modal",je="hover",He="focus";class $e extends R{constructor(t,e){if(void 0===i)throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");super(t),this._isEnabled=!0,this._timeout=0,this._hoverState="",this._activeTrigger={},this._popper=null,this._config=this._getConfig(e),this.tip=null,this._setListeners()}static get Default(){return Le}static get NAME(){return Ae}static get Event(){return Se}static get DefaultType(){return Ce}enable(){this._isEnabled=!0}disable(){this._isEnabled=!1}toggleEnabled(){this._isEnabled=!this._isEnabled}toggle(t){if(this._isEnabled)if(t){const e=this._initializeOnDelegatedTarget(t);e._activeTrigger.click=!e._activeTrigger.click,e._isWithActiveTrigger()?e._enter(null,e):e._leave(null,e)}else{if(this.getTipElement().classList.contains(Ne))return void this._leave(null,this);this._enter(null,this)}}dispose(){clearTimeout(this._timeout),$.off(this._element.closest(xe),Me,this._hideModalHandler),this.tip&&this.tip.remove(),this._disposePopper(),super.dispose()}show(){if("none"===this._element.style.display)throw new Error("Please use show on visible elements");if(!this.isWithContent()||!this._isEnabled)return;const t=$.trigger(this._element,this.constructor.Event.SHOW),e=g(this._element),s=null===e?this._element.ownerDocument.documentElement.contains(this._element):e.contains(this._element);if(t.defaultPrevented||!s)return;"tooltip"===this.constructor.NAME&&this.tip&&this.getTitle()!==this.tip.querySelector(Pe).innerHTML&&(this._disposePopper(),this.tip.remove(),this.tip=null);const n=this.getTipElement(),o=(t=>{do{t+=Math.floor(1e6*Math.random())}while(document.getElementById(t));return t})(this.constructor.NAME);n.setAttribute("id",o),this._element.setAttribute("aria-describedby",o),this._config.animation&&n.classList.add(Oe);const r="function"==typeof this._config.placement?this._config.placement.call(this,n,this._element):this._config.placement,a=this._getAttachment(r);this._addAttachmentClass(a);const{container:l}=this._config;z.set(n,this.constructor.DATA_KEY,this),this._element.ownerDocument.documentElement.contains(this.tip)||(l.append(n),$.trigger(this._element,this.constructor.Event.INSERTED)),this._popper?this._popper.update():this._popper=i.createPopper(this._element,n,this._getPopperConfig(a)),n.classList.add(Ne);const c=this._resolvePossibleFunction(this._config.customClass);c&&n.classList.add(...c.split(" ")),"ontouchstart"in document.documentElement&&[].concat(...document.body.children).forEach((t=>{$.on(t,"mouseover",_)}));const h=this.tip.classList.contains(Oe);this._queueCallback((()=>{const t=this._hoverState;this._hoverState=null,$.trigger(this._element,this.constructor.Event.SHOWN),t===Ie&&this._leave(null,this)}),this.tip,h)}hide(){if(!this._popper)return;const t=this.getTipElement();if($.trigger(this._element,this.constructor.Event.HIDE).defaultPrevented)return;t.classList.remove(Ne),"ontouchstart"in document.documentElement&&[].concat(...document.body.children).forEach((t=>$.off(t,"mouseover",_))),this._activeTrigger.click=!1,this._activeTrigger.focus=!1,this._activeTrigger.hover=!1;const e=this.tip.classList.contains(Oe);this._queueCallback((()=>{this._isWithActiveTrigger()||(this._hoverState!==De&&t.remove(),this._cleanTipClass(),this._element.removeAttribute("aria-describedby"),$.trigger(this._element,this.constructor.Event.HIDDEN),this._disposePopper())}),this.tip,e),this._hoverState=""}update(){null!==this._popper&&this._popper.update()}isWithContent(){return Boolean(this.getTitle())}getTipElement(){if(this.tip)return this.tip;const t=document.createElement("div");t.innerHTML=this._config.template;const e=t.children[0];return this.setContent(e),e.classList.remove(Oe,Ne),this.tip=e,this.tip}setContent(t){this._sanitizeAndSetContent(t,this.getTitle(),Pe)}_sanitizeAndSetContent(t,e,i){const s=Y.findOne(i,t);e||!s?this.setElementContent(s,e):s.remove()}setElementContent(t,e){if(null!==t)return l(e)?(e=c(e),void(this._config.html?e.parentNode!==t&&(t.innerHTML="",t.append(e)):t.textContent=e.textContent)):void(this._config.html?(this._config.sanitize&&(e=we(e,this._config.allowList,this._config.sanitizeFn)),t.innerHTML=e):t.textContent=e)}getTitle(){const t=this._element.getAttribute("data-bs-original-title")||this._config.title;return this._resolvePossibleFunction(t)}updateAttachment(t){return"right"===t?"end":"left"===t?"start":t}_initializeOnDelegatedTarget(t,e){return e||this.constructor.getOrCreateInstance(t.delegateTarget,this._getDelegateConfig())}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_resolvePossibleFunction(t){return"function"==typeof t?t.call(this._element):t}_getPopperConfig(t){const e={placement:t,modifiers:[{name:"flip",options:{fallbackPlacements:this._config.fallbackPlacements}},{name:"offset",options:{offset:this._getOffset()}},{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"arrow",options:{element:`.${this.constructor.NAME}-arrow`}},{name:"onChange",enabled:!0,phase:"afterWrite",fn:t=>this._handlePopperPlacementChange(t)}],onFirstUpdate:t=>{t.options.placement!==t.placement&&this._handlePopperPlacementChange(t)}};return{...e,..."function"==typeof this._config.popperConfig?this._config.popperConfig(e):this._config.popperConfig}}_addAttachmentClass(t){this.getTipElement().classList.add(`${this._getBasicClassPrefix()}-${this.updateAttachment(t)}`)}_getAttachment(t){return ke[t.toUpperCase()]}_setListeners(){this._config.trigger.split(" ").forEach((t=>{if("click"===t)$.on(this._element,this.constructor.Event.CLICK,this._config.selector,(t=>this.toggle(t)));else if("manual"!==t){const e=t===je?this.constructor.Event.MOUSEENTER:this.constructor.Event.FOCUSIN,i=t===je?this.constructor.Event.MOUSELEAVE:this.constructor.Event.FOCUSOUT;$.on(this._element,e,this._config.selector,(t=>this._enter(t))),$.on(this._element,i,this._config.selector,(t=>this._leave(t)))}})),this._hideModalHandler=()=>{this._element&&this.hide()},$.on(this._element.closest(xe),Me,this._hideModalHandler),this._config.selector?this._config={...this._config,trigger:"manual",selector:""}:this._fixTitle()}_fixTitle(){const t=this._element.getAttribute("title"),e=typeof this._element.getAttribute("data-bs-original-title");(t||"string"!==e)&&(this._element.setAttribute("data-bs-original-title",t||""),!t||this._element.getAttribute("aria-label")||this._element.textContent||this._element.setAttribute("aria-label",t),this._element.setAttribute("title",""))}_enter(t,e){e=this._initializeOnDelegatedTarget(t,e),t&&(e._activeTrigger["focusin"===t.type?He:je]=!0),e.getTipElement().classList.contains(Ne)||e._hoverState===De?e._hoverState=De:(clearTimeout(e._timeout),e._hoverState=De,e._config.delay&&e._config.delay.show?e._timeout=setTimeout((()=>{e._hoverState===De&&e.show()}),e._config.delay.show):e.show())}_leave(t,e){e=this._initializeOnDelegatedTarget(t,e),t&&(e._activeTrigger["focusout"===t.type?He:je]=e._element.contains(t.relatedTarget)),e._isWithActiveTrigger()||(clearTimeout(e._timeout),e._hoverState=Ie,e._config.delay&&e._config.delay.hide?e._timeout=setTimeout((()=>{e._hoverState===Ie&&e.hide()}),e._config.delay.hide):e.hide())}_isWithActiveTrigger(){for(const t in this._activeTrigger)if(this._activeTrigger[t])return!0;return!1}_getConfig(t){const e=X.getDataAttributes(this._element);return Object.keys(e).forEach((t=>{Te.has(t)&&delete e[t]})),(t={...this.constructor.Default,...e,..."object"==typeof t&&t?t:{}}).container=!1===t.container?document.body:c(t.container),"number"==typeof t.delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),h(Ae,t,this.constructor.DefaultType),t.sanitize&&(t.template=we(t.template,t.allowList,t.sanitizeFn)),t}_getDelegateConfig(){const t={};for(const e in this._config)this.constructor.Default[e]!==this._config[e]&&(t[e]=this._config[e]);return t}_cleanTipClass(){const t=this.getTipElement(),e=new RegExp(`(^|\\s)${this._getBasicClassPrefix()}\\S+`,"g"),i=t.getAttribute("class").match(e);null!==i&&i.length>0&&i.map((t=>t.trim())).forEach((e=>t.classList.remove(e)))}_getBasicClassPrefix(){return"bs-tooltip"}_handlePopperPlacementChange(t){const{state:e}=t;e&&(this.tip=e.elements.popper,this._cleanTipClass(),this._addAttachmentClass(this._getAttachment(e.placement)))}_disposePopper(){this._popper&&(this._popper.destroy(),this._popper=null)}static jQueryInterface(t){return this.each((function(){const e=$e.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}v($e);const Be={...$e.Default,placement:"right",offset:[0,8],trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>'},ze={...$e.DefaultType,content:"(string|element|function)"},Re={HIDE:"hide.bs.popover",HIDDEN:"hidden.bs.popover",SHOW:"show.bs.popover",SHOWN:"shown.bs.popover",INSERTED:"inserted.bs.popover",CLICK:"click.bs.popover",FOCUSIN:"focusin.bs.popover",FOCUSOUT:"focusout.bs.popover",MOUSEENTER:"mouseenter.bs.popover",MOUSELEAVE:"mouseleave.bs.popover"};class Fe extends $e{static get Default(){return Be}static get NAME(){return"popover"}static get Event(){return Re}static get DefaultType(){return ze}isWithContent(){return this.getTitle()||this._getContent()}setContent(t){this._sanitizeAndSetContent(t,this.getTitle(),".popover-header"),this._sanitizeAndSetContent(t,this._getContent(),".popover-body")}_getContent(){return this._resolvePossibleFunction(this._config.content)}_getBasicClassPrefix(){return"bs-popover"}static jQueryInterface(t){return this.each((function(){const e=Fe.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}v(Fe);const qe="scrollspy",We={offset:10,method:"auto",target:""},Ue={offset:"number",method:"string",target:"(string|element)"},Ke="active",Ve=".nav-link, .list-group-item, .dropdown-item",Xe="position";class Ye extends R{constructor(t,e){super(t),this._scrollElement="BODY"===this._element.tagName?window:this._element,this._config=this._getConfig(e),this._offsets=[],this._targets=[],this._activeTarget=null,this._scrollHeight=0,$.on(this._scrollElement,"scroll.bs.scrollspy",(()=>this._process())),this.refresh(),this._process()}static get Default(){return We}static get NAME(){return qe}refresh(){const t=this._scrollElement===this._scrollElement.window?"offset":Xe,e="auto"===this._config.method?t:this._config.method,i=e===Xe?this._getScrollTop():0;this._offsets=[],this._targets=[],this._scrollHeight=this._getScrollHeight(),Y.find(Ve,this._config.target).map((t=>{const s=o(t),n=s?Y.findOne(s):null;if(n){const t=n.getBoundingClientRect();if(t.width||t.height)return[X[e](n).top+i,s]}return null})).filter((t=>t)).sort(((t,e)=>t[0]-e[0])).forEach((t=>{this._offsets.push(t[0]),this._targets.push(t[1])}))}dispose(){$.off(this._scrollElement,".bs.scrollspy"),super.dispose()}_getConfig(t){return(t={...We,...X.getDataAttributes(this._element),..."object"==typeof t&&t?t:{}}).target=c(t.target)||document.documentElement,h(qe,t,Ue),t}_getScrollTop(){return this._scrollElement===window?this._scrollElement.pageYOffset:this._scrollElement.scrollTop}_getScrollHeight(){return this._scrollElement.scrollHeight||Math.max(document.body.scrollHeight,document.documentElement.scrollHeight)}_getOffsetHeight(){return this._scrollElement===window?window.innerHeight:this._scrollElement.getBoundingClientRect().height}_process(){const t=this._getScrollTop()+this._config.offset,e=this._getScrollHeight(),i=this._config.offset+e-this._getOffsetHeight();if(this._scrollHeight!==e&&this.refresh(),t>=i){const t=this._targets[this._targets.length-1];this._activeTarget!==t&&this._activate(t)}else{if(this._activeTarget&&t<this._offsets[0]&&this._offsets[0]>0)return this._activeTarget=null,void this._clear();for(let e=this._offsets.length;e--;)this._activeTarget!==this._targets[e]&&t>=this._offsets[e]&&(void 0===this._offsets[e+1]||t<this._offsets[e+1])&&this._activate(this._targets[e])}}_activate(t){this._activeTarget=t,this._clear();const e=Ve.split(",").map((e=>`${e}[data-bs-target="${t}"],${e}[href="${t}"]`)),i=Y.findOne(e.join(","),this._config.target);i.classList.add(Ke),i.classList.contains("dropdown-item")?Y.findOne(".dropdown-toggle",i.closest(".dropdown")).classList.add(Ke):Y.parents(i,".nav, .list-group").forEach((t=>{Y.prev(t,".nav-link, .list-group-item").forEach((t=>t.classList.add(Ke))),Y.prev(t,".nav-item").forEach((t=>{Y.children(t,".nav-link").forEach((t=>t.classList.add(Ke)))}))})),$.trigger(this._scrollElement,"activate.bs.scrollspy",{relatedTarget:t})}_clear(){Y.find(Ve,this._config.target).filter((t=>t.classList.contains(Ke))).forEach((t=>t.classList.remove(Ke)))}static jQueryInterface(t){return this.each((function(){const e=Ye.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}$.on(window,"load.bs.scrollspy.data-api",(()=>{Y.find('[data-bs-spy="scroll"]').forEach((t=>new Ye(t)))})),v(Ye);const Qe="active",Ge="fade",Ze="show",Je=".active",ti=":scope > li > .active";class ei extends R{static get NAME(){return"tab"}show(){if(this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE&&this._element.classList.contains(Qe))return;let t;const e=r(this._element),i=this._element.closest(".nav, .list-group");if(i){const e="UL"===i.nodeName||"OL"===i.nodeName?ti:Je;t=Y.find(e,i),t=t[t.length-1]}const s=t?$.trigger(t,"hide.bs.tab",{relatedTarget:this._element}):null;if($.trigger(this._element,"show.bs.tab",{relatedTarget:t}).defaultPrevented||null!==s&&s.defaultPrevented)return;this._activate(this._element,i);const n=()=>{$.trigger(t,"hidden.bs.tab",{relatedTarget:this._element}),$.trigger(this._element,"shown.bs.tab",{relatedTarget:t})};e?this._activate(e,e.parentNode,n):n()}_activate(t,e,i){const s=(!e||"UL"!==e.nodeName&&"OL"!==e.nodeName?Y.children(e,Je):Y.find(ti,e))[0],n=i&&s&&s.classList.contains(Ge),o=()=>this._transitionComplete(t,s,i);s&&n?(s.classList.remove(Ze),this._queueCallback(o,t,!0)):o()}_transitionComplete(t,e,i){if(e){e.classList.remove(Qe);const t=Y.findOne(":scope > .dropdown-menu .active",e.parentNode);t&&t.classList.remove(Qe),"tab"===e.getAttribute("role")&&e.setAttribute("aria-selected",!1)}t.classList.add(Qe),"tab"===t.getAttribute("role")&&t.setAttribute("aria-selected",!0),f(t),t.classList.contains(Ge)&&t.classList.add(Ze);let s=t.parentNode;if(s&&"LI"===s.nodeName&&(s=s.parentNode),s&&s.classList.contains("dropdown-menu")){const e=t.closest(".dropdown");e&&Y.find(".dropdown-toggle",e).forEach((t=>t.classList.add(Qe))),t.setAttribute("aria-expanded",!0)}i&&i()}static jQueryInterface(t){return this.each((function(){const e=ei.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}$.on(document,"click.bs.tab.data-api",'[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',(function(t){["A","AREA"].includes(this.tagName)&&t.preventDefault(),u(this)||ei.getOrCreateInstance(this).show()})),v(ei);const ii="toast",si="hide",ni="show",oi="showing",ri={animation:"boolean",autohide:"boolean",delay:"number"},ai={animation:!0,autohide:!0,delay:5e3};class li extends R{constructor(t,e){super(t),this._config=this._getConfig(e),this._timeout=null,this._hasMouseInteraction=!1,this._hasKeyboardInteraction=!1,this._setListeners()}static get DefaultType(){return ri}static get Default(){return ai}static get NAME(){return ii}show(){$.trigger(this._element,"show.bs.toast").defaultPrevented||(this._clearTimeout(),this._config.animation&&this._element.classList.add("fade"),this._element.classList.remove(si),f(this._element),this._element.classList.add(ni),this._element.classList.add(oi),this._queueCallback((()=>{this._element.classList.remove(oi),$.trigger(this._element,"shown.bs.toast"),this._maybeScheduleHide()}),this._element,this._config.animation))}hide(){this._element.classList.contains(ni)&&($.trigger(this._element,"hide.bs.toast").defaultPrevented||(this._element.classList.add(oi),this._queueCallback((()=>{this._element.classList.add(si),this._element.classList.remove(oi),this._element.classList.remove(ni),$.trigger(this._element,"hidden.bs.toast")}),this._element,this._config.animation)))}dispose(){this._clearTimeout(),this._element.classList.contains(ni)&&this._element.classList.remove(ni),super.dispose()}_getConfig(t){return t={...ai,...X.getDataAttributes(this._element),..."object"==typeof t&&t?t:{}},h(ii,t,this.constructor.DefaultType),t}_maybeScheduleHide(){this._config.autohide&&(this._hasMouseInteraction||this._hasKeyboardInteraction||(this._timeout=setTimeout((()=>{this.hide()}),this._config.delay)))}_onInteraction(t,e){switch(t.type){case"mouseover":case"mouseout":this._hasMouseInteraction=e;break;case"focusin":case"focusout":this._hasKeyboardInteraction=e}if(e)return void this._clearTimeout();const i=t.relatedTarget;this._element===i||this._element.contains(i)||this._maybeScheduleHide()}_setListeners(){$.on(this._element,"mouseover.bs.toast",(t=>this._onInteraction(t,!0))),$.on(this._element,"mouseout.bs.toast",(t=>this._onInteraction(t,!1))),$.on(this._element,"focusin.bs.toast",(t=>this._onInteraction(t,!0))),$.on(this._element,"focusout.bs.toast",(t=>this._onInteraction(t,!1)))}_clearTimeout(){clearTimeout(this._timeout),this._timeout=null}static jQueryInterface(t){return this.each((function(){const e=li.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}return F(li),v(li),{Alert:q,Button:U,Carousel:at,Collapse:mt,Dropdown:Ht,Modal:he,Offcanvas:me,Popover:Fe,ScrollSpy:Ye,Tab:ei,Toast:li,Tooltip:$e}}));
    7 //# sourceMappingURL=bootstrap.min.js.map
     2 * Bootstrap v3.4.1 (https://getbootstrap.com/)
     3 * Copyright 2011-2019 Twitter, Inc.
     4 * Licensed under the MIT license
     5 */
     6if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(t){"use strict";var e=jQuery.fn.jquery.split(" ")[0].split(".");if(e[0]<2&&e[1]<9||1==e[0]&&9==e[1]&&e[2]<1||3<e[0])throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(),function(n){"use strict";n.fn.emulateTransitionEnd=function(t){var e=!1,i=this;n(this).one("bsTransitionEnd",function(){e=!0});return setTimeout(function(){e||n(i).trigger(n.support.transition.end)},t),this},n(function(){n.support.transition=function o(){var t=document.createElement("bootstrap"),e={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var i in e)if(t.style[i]!==undefined)return{end:e[i]};return!1}(),n.support.transition&&(n.event.special.bsTransitionEnd={bindType:n.support.transition.end,delegateType:n.support.transition.end,handle:function(t){if(n(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})})}(jQuery),function(s){"use strict";var e='[data-dismiss="alert"]',a=function(t){s(t).on("click",e,this.close)};a.VERSION="3.4.1",a.TRANSITION_DURATION=150,a.prototype.close=function(t){var e=s(this),i=e.attr("data-target");i||(i=(i=e.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=s(document).find(i);function n(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=e.closest(".alert")),o.trigger(t=s.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),s.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",n).emulateTransitionEnd(a.TRANSITION_DURATION):n())};var t=s.fn.alert;s.fn.alert=function o(i){return this.each(function(){var t=s(this),e=t.data("bs.alert");e||t.data("bs.alert",e=new a(this)),"string"==typeof i&&e[i].call(t)})},s.fn.alert.Constructor=a,s.fn.alert.noConflict=function(){return s.fn.alert=t,this},s(document).on("click.bs.alert.data-api",e,a.prototype.close)}(jQuery),function(s){"use strict";var n=function(t,e){this.$element=s(t),this.options=s.extend({},n.DEFAULTS,e),this.isLoading=!1};function i(o){return this.each(function(){var t=s(this),e=t.data("bs.button"),i="object"==typeof o&&o;e||t.data("bs.button",e=new n(this,i)),"toggle"==o?e.toggle():o&&e.setState(o)})}n.VERSION="3.4.1",n.DEFAULTS={loadingText:"loading..."},n.prototype.setState=function(t){var e="disabled",i=this.$element,o=i.is("input")?"val":"html",n=i.data();t+="Text",null==n.resetText&&i.data("resetText",i[o]()),setTimeout(s.proxy(function(){i[o](null==n[t]?this.options[t]:n[t]),"loadingText"==t?(this.isLoading=!0,i.addClass(e).attr(e,e).prop(e,!0)):this.isLoading&&(this.isLoading=!1,i.removeClass(e).removeAttr(e).prop(e,!1))},this),0)},n.prototype.toggle=function(){var t=!0,e=this.$element.closest('[data-toggle="buttons"]');if(e.length){var i=this.$element.find("input");"radio"==i.prop("type")?(i.prop("checked")&&(t=!1),e.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==i.prop("type")&&(i.prop("checked")!==this.$element.hasClass("active")&&(t=!1),this.$element.toggleClass("active")),i.prop("checked",this.$element.hasClass("active")),t&&i.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var t=s.fn.button;s.fn.button=i,s.fn.button.Constructor=n,s.fn.button.noConflict=function(){return s.fn.button=t,this},s(document).on("click.bs.button.data-api",'[data-toggle^="button"]',function(t){var e=s(t.target).closest(".btn");i.call(e,"toggle"),s(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),e.is("input,button")?e.trigger("focus"):e.find("input:visible,button:visible").first().trigger("focus"))}).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',function(t){s(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))})}(jQuery),function(p){"use strict";var c=function(t,e){this.$element=p(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=e,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",p.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",p.proxy(this.pause,this)).on("mouseleave.bs.carousel",p.proxy(this.cycle,this))};function r(n){return this.each(function(){var t=p(this),e=t.data("bs.carousel"),i=p.extend({},c.DEFAULTS,t.data(),"object"==typeof n&&n),o="string"==typeof n?n:i.slide;e||t.data("bs.carousel",e=new c(this,i)),"number"==typeof n?e.to(n):o?e[o]():i.interval&&e.pause().cycle()})}c.VERSION="3.4.1",c.TRANSITION_DURATION=600,c.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},c.prototype.keydown=function(t){if(!/input|textarea/i.test(t.target.tagName)){switch(t.which){case 37:this.prev();break;case 39:this.next();break;default:return}t.preventDefault()}},c.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(p.proxy(this.next,this),this.options.interval)),this},c.prototype.getItemIndex=function(t){return this.$items=t.parent().children(".item"),this.$items.index(t||this.$active)},c.prototype.getItemForDirection=function(t,e){var i=this.getItemIndex(e);if(("prev"==t&&0===i||"next"==t&&i==this.$items.length-1)&&!this.options.wrap)return e;var o=(i+("prev"==t?-1:1))%this.$items.length;return this.$items.eq(o)},c.prototype.to=function(t){var e=this,i=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(t>this.$items.length-1||t<0))return this.sliding?this.$element.one("slid.bs.carousel",function(){e.to(t)}):i==t?this.pause().cycle():this.slide(i<t?"next":"prev",this.$items.eq(t))},c.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&p.support.transition&&(this.$element.trigger(p.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},c.prototype.next=function(){if(!this.sliding)return this.slide("next")},c.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},c.prototype.slide=function(t,e){var i=this.$element.find(".item.active"),o=e||this.getItemForDirection(t,i),n=this.interval,s="next"==t?"left":"right",a=this;if(o.hasClass("active"))return this.sliding=!1;var r=o[0],l=p.Event("slide.bs.carousel",{relatedTarget:r,direction:s});if(this.$element.trigger(l),!l.isDefaultPrevented()){if(this.sliding=!0,n&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var h=p(this.$indicators.children()[this.getItemIndex(o)]);h&&h.addClass("active")}var d=p.Event("slid.bs.carousel",{relatedTarget:r,direction:s});return p.support.transition&&this.$element.hasClass("slide")?(o.addClass(t),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(s),o.addClass(s),i.one("bsTransitionEnd",function(){o.removeClass([t,s].join(" ")).addClass("active"),i.removeClass(["active",s].join(" ")),a.sliding=!1,setTimeout(function(){a.$element.trigger(d)},0)}).emulateTransitionEnd(c.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(d)),n&&this.cycle(),this}};var t=p.fn.carousel;p.fn.carousel=r,p.fn.carousel.Constructor=c,p.fn.carousel.noConflict=function(){return p.fn.carousel=t,this};var e=function(t){var e=p(this),i=e.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=e.attr("data-target")||i,n=p(document).find(o);if(n.hasClass("carousel")){var s=p.extend({},n.data(),e.data()),a=e.attr("data-slide-to");a&&(s.interval=!1),r.call(n,s),a&&n.data("bs.carousel").to(a),t.preventDefault()}};p(document).on("click.bs.carousel.data-api","[data-slide]",e).on("click.bs.carousel.data-api","[data-slide-to]",e),p(window).on("load",function(){p('[data-ride="carousel"]').each(function(){var t=p(this);r.call(t,t.data())})})}(jQuery),function(a){"use strict";var r=function(t,e){this.$element=a(t),this.options=a.extend({},r.DEFAULTS,e),this.$trigger=a('[data-toggle="collapse"][href="#'+t.id+'"],[data-toggle="collapse"][data-target="#'+t.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var e,i=t.attr("data-target")||(e=t.attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"");return a(document).find(i)}function l(o){return this.each(function(){var t=a(this),e=t.data("bs.collapse"),i=a.extend({},r.DEFAULTS,t.data(),"object"==typeof o&&o);!e&&i.toggle&&/show|hide/.test(o)&&(i.toggle=!1),e||t.data("bs.collapse",e=new r(this,i)),"string"==typeof o&&e[o]()})}r.VERSION="3.4.1",r.TRANSITION_DURATION=350,r.DEFAULTS={toggle:!0},r.prototype.dimension=function(){return this.$element.hasClass("width")?"width":"height"},r.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var t,e=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(e&&e.length&&(t=e.data("bs.collapse"))&&t.transitioning)){var i=a.Event("show.bs.collapse");if(this.$element.trigger(i),!i.isDefaultPrevented()){e&&e.length&&(l.call(e,"hide"),t||e.data("bs.collapse",null));var o=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[o](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var n=function(){this.$element.removeClass("collapsing").addClass("collapse in")[o](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!a.support.transition)return n.call(this);var s=a.camelCase(["scroll",o].join("-"));this.$element.one("bsTransitionEnd",a.proxy(n,this)).emulateTransitionEnd(r.TRANSITION_DURATION)[o](this.$element[0][s])}}}},r.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var t=a.Event("hide.bs.collapse");if(this.$element.trigger(t),!t.isDefaultPrevented()){var e=this.dimension();this.$element[e](this.$element[e]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!a.support.transition)return i.call(this);this.$element[e](0).one("bsTransitionEnd",a.proxy(i,this)).emulateTransitionEnd(r.TRANSITION_DURATION)}}},r.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},r.prototype.getParent=function(){return a(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(a.proxy(function(t,e){var i=a(e);this.addAriaAndCollapsedClass(n(i),i)},this)).end()},r.prototype.addAriaAndCollapsedClass=function(t,e){var i=t.hasClass("in");t.attr("aria-expanded",i),e.toggleClass("collapsed",!i).attr("aria-expanded",i)};var t=a.fn.collapse;a.fn.collapse=l,a.fn.collapse.Constructor=r,a.fn.collapse.noConflict=function(){return a.fn.collapse=t,this},a(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',function(t){var e=a(this);e.attr("data-target")||t.preventDefault();var i=n(e),o=i.data("bs.collapse")?"toggle":e.data();l.call(i,o)})}(jQuery),function(a){"use strict";var r='[data-toggle="dropdown"]',o=function(t){a(t).on("click.bs.dropdown",this.toggle)};function l(t){var e=t.attr("data-target");e||(e=(e=t.attr("href"))&&/#[A-Za-z]/.test(e)&&e.replace(/.*(?=#[^\s]*$)/,""));var i="#"!==e?a(document).find(e):null;return i&&i.length?i:t.parent()}function s(o){o&&3===o.which||(a(".dropdown-backdrop").remove(),a(r).each(function(){var t=a(this),e=l(t),i={relatedTarget:this};e.hasClass("open")&&(o&&"click"==o.type&&/input|textarea/i.test(o.target.tagName)&&a.contains(e[0],o.target)||(e.trigger(o=a.Event("hide.bs.dropdown",i)),o.isDefaultPrevented()||(t.attr("aria-expanded","false"),e.removeClass("open").trigger(a.Event("hidden.bs.dropdown",i)))))}))}o.VERSION="3.4.1",o.prototype.toggle=function(t){var e=a(this);if(!e.is(".disabled, :disabled")){var i=l(e),o=i.hasClass("open");if(s(),!o){"ontouchstart"in document.documentElement&&!i.closest(".navbar-nav").length&&a(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(a(this)).on("click",s);var n={relatedTarget:this};if(i.trigger(t=a.Event("show.bs.dropdown",n)),t.isDefaultPrevented())return;e.trigger("focus").attr("aria-expanded","true"),i.toggleClass("open").trigger(a.Event("shown.bs.dropdown",n))}return!1}},o.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var e=a(this);if(t.preventDefault(),t.stopPropagation(),!e.is(".disabled, :disabled")){var i=l(e),o=i.hasClass("open");if(!o&&27!=t.which||o&&27==t.which)return 27==t.which&&i.find(r).trigger("focus"),e.trigger("click");var n=i.find(".dropdown-menu li:not(.disabled):visible a");if(n.length){var s=n.index(t.target);38==t.which&&0<s&&s--,40==t.which&&s<n.length-1&&s++,~s||(s=0),n.eq(s).trigger("focus")}}}};var t=a.fn.dropdown;a.fn.dropdown=function e(i){return this.each(function(){var t=a(this),e=t.data("bs.dropdown");e||t.data("bs.dropdown",e=new o(this)),"string"==typeof i&&e[i].call(t)})},a.fn.dropdown.Constructor=o,a.fn.dropdown.noConflict=function(){return a.fn.dropdown=t,this},a(document).on("click.bs.dropdown.data-api",s).on("click.bs.dropdown.data-api",".dropdown form",function(t){t.stopPropagation()}).on("click.bs.dropdown.data-api",r,o.prototype.toggle).on("keydown.bs.dropdown.data-api",r,o.prototype.keydown).on("keydown.bs.dropdown.data-api",".dropdown-menu",o.prototype.keydown)}(jQuery),function(a){"use strict";var s=function(t,e){this.options=e,this.$body=a(document.body),this.$element=a(t),this.$dialog=this.$element.find(".modal-dialog"),this.$backdrop=null,this.isShown=null,this.originalBodyPad=null,this.scrollbarWidth=0,this.ignoreBackdropClick=!1,this.fixedContent=".navbar-fixed-top, .navbar-fixed-bottom",this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,a.proxy(function(){this.$element.trigger("loaded.bs.modal")},this))};function r(o,n){return this.each(function(){var t=a(this),e=t.data("bs.modal"),i=a.extend({},s.DEFAULTS,t.data(),"object"==typeof o&&o);e||t.data("bs.modal",e=new s(this,i)),"string"==typeof o?e[o](n):i.show&&e.show(n)})}s.VERSION="3.4.1",s.TRANSITION_DURATION=300,s.BACKDROP_TRANSITION_DURATION=150,s.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},s.prototype.toggle=function(t){return this.isShown?this.hide():this.show(t)},s.prototype.show=function(i){var o=this,t=a.Event("show.bs.modal",{relatedTarget:i});this.$element.trigger(t),this.isShown||t.isDefaultPrevented()||(this.isShown=!0,this.checkScrollbar(),this.setScrollbar(),this.$body.addClass("modal-open"),this.escape(),this.resize(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',a.proxy(this.hide,this)),this.$dialog.on("mousedown.dismiss.bs.modal",function(){o.$element.one("mouseup.dismiss.bs.modal",function(t){a(t.target).is(o.$element)&&(o.ignoreBackdropClick=!0)})}),this.backdrop(function(){var t=a.support.transition&&o.$element.hasClass("fade");o.$element.parent().length||o.$element.appendTo(o.$body),o.$element.show().scrollTop(0),o.adjustDialog(),t&&o.$element[0].offsetWidth,o.$element.addClass("in"),o.enforceFocus();var e=a.Event("shown.bs.modal",{relatedTarget:i});t?o.$dialog.one("bsTransitionEnd",function(){o.$element.trigger("focus").trigger(e)}).emulateTransitionEnd(s.TRANSITION_DURATION):o.$element.trigger("focus").trigger(e)}))},s.prototype.hide=function(t){t&&t.preventDefault(),t=a.Event("hide.bs.modal"),this.$element.trigger(t),this.isShown&&!t.isDefaultPrevented()&&(this.isShown=!1,this.escape(),this.resize(),a(document).off("focusin.bs.modal"),this.$element.removeClass("in").off("click.dismiss.bs.modal").off("mouseup.dismiss.bs.modal"),this.$dialog.off("mousedown.dismiss.bs.modal"),a.support.transition&&this.$element.hasClass("fade")?this.$element.one("bsTransitionEnd",a.proxy(this.hideModal,this)).emulateTransitionEnd(s.TRANSITION_DURATION):this.hideModal())},s.prototype.enforceFocus=function(){a(document).off("focusin.bs.modal").on("focusin.bs.modal",a.proxy(function(t){document===t.target||this.$element[0]===t.target||this.$element.has(t.target).length||this.$element.trigger("focus")},this))},s.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keydown.dismiss.bs.modal",a.proxy(function(t){27==t.which&&this.hide()},this)):this.isShown||this.$element.off("keydown.dismiss.bs.modal")},s.prototype.resize=function(){this.isShown?a(window).on("resize.bs.modal",a.proxy(this.handleUpdate,this)):a(window).off("resize.bs.modal")},s.prototype.hideModal=function(){var t=this;this.$element.hide(),this.backdrop(function(){t.$body.removeClass("modal-open"),t.resetAdjustments(),t.resetScrollbar(),t.$element.trigger("hidden.bs.modal")})},s.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},s.prototype.backdrop=function(t){var e=this,i=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var o=a.support.transition&&i;if(this.$backdrop=a(document.createElement("div")).addClass("modal-backdrop "+i).appendTo(this.$body),this.$element.on("click.dismiss.bs.modal",a.proxy(function(t){this.ignoreBackdropClick?this.ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus():this.hide())},this)),o&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!t)return;o?this.$backdrop.one("bsTransitionEnd",t).emulateTransitionEnd(s.BACKDROP_TRANSITION_DURATION):t()}else if(!this.isShown&&this.$backdrop){this.$backdrop.removeClass("in");var n=function(){e.removeBackdrop(),t&&t()};a.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one("bsTransitionEnd",n).emulateTransitionEnd(s.BACKDROP_TRANSITION_DURATION):n()}else t&&t()},s.prototype.handleUpdate=function(){this.adjustDialog()},s.prototype.adjustDialog=function(){var t=this.$element[0].scrollHeight>document.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&t?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!t?this.scrollbarWidth:""})},s.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},s.prototype.checkScrollbar=function(){var t=window.innerWidth;if(!t){var e=document.documentElement.getBoundingClientRect();t=e.right-Math.abs(e.left)}this.bodyIsOverflowing=document.body.clientWidth<t,this.scrollbarWidth=this.measureScrollbar()},s.prototype.setScrollbar=function(){var t=parseInt(this.$body.css("padding-right")||0,10);this.originalBodyPad=document.body.style.paddingRight||"";var n=this.scrollbarWidth;this.bodyIsOverflowing&&(this.$body.css("padding-right",t+n),a(this.fixedContent).each(function(t,e){var i=e.style.paddingRight,o=a(e).css("padding-right");a(e).data("padding-right",i).css("padding-right",parseFloat(o)+n+"px")}))},s.prototype.resetScrollbar=function(){this.$body.css("padding-right",this.originalBodyPad),a(this.fixedContent).each(function(t,e){var i=a(e).data("padding-right");a(e).removeData("padding-right"),e.style.paddingRight=i||""})},s.prototype.measureScrollbar=function(){var t=document.createElement("div");t.className="modal-scrollbar-measure",this.$body.append(t);var e=t.offsetWidth-t.clientWidth;return this.$body[0].removeChild(t),e};var t=a.fn.modal;a.fn.modal=r,a.fn.modal.Constructor=s,a.fn.modal.noConflict=function(){return a.fn.modal=t,this},a(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',function(t){var e=a(this),i=e.attr("href"),o=e.attr("data-target")||i&&i.replace(/.*(?=#[^\s]+$)/,""),n=a(document).find(o),s=n.data("bs.modal")?"toggle":a.extend({remote:!/#/.test(i)&&i},n.data(),e.data());e.is("a")&&t.preventDefault(),n.one("show.bs.modal",function(t){t.isDefaultPrevented()||n.one("hidden.bs.modal",function(){e.is(":visible")&&e.trigger("focus")})}),r.call(n,s,this)})}(jQuery),function(g){"use strict";var o=["sanitize","whiteList","sanitizeFn"],a=["background","cite","href","itemtype","longdesc","poster","src","xlink:href"],t={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},r=/^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi,l=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;function u(t,e){var i=t.nodeName.toLowerCase();if(-1!==g.inArray(i,e))return-1===g.inArray(i,a)||Boolean(t.nodeValue.match(r)||t.nodeValue.match(l));for(var o=g(e).filter(function(t,e){return e instanceof RegExp}),n=0,s=o.length;n<s;n++)if(i.match(o[n]))return!0;return!1}function n(t,e,i){if(0===t.length)return t;if(i&&"function"==typeof i)return i(t);if(!document.implementation||!document.implementation.createHTMLDocument)return t;var o=document.implementation.createHTMLDocument("sanitization");o.body.innerHTML=t;for(var n=g.map(e,function(t,e){return e}),s=g(o.body).find("*"),a=0,r=s.length;a<r;a++){var l=s[a],h=l.nodeName.toLowerCase();if(-1!==g.inArray(h,n))for(var d=g.map(l.attributes,function(t){return t}),p=[].concat(e["*"]||[],e[h]||[]),c=0,f=d.length;c<f;c++)u(d[c],p)||l.removeAttribute(d[c].nodeName);else l.parentNode.removeChild(l)}return o.body.innerHTML}var m=function(t,e){this.type=null,this.options=null,this.enabled=null,this.timeout=null,this.hoverState=null,this.$element=null,this.inState=null,this.init("tooltip",t,e)};m.VERSION="3.4.1",m.TRANSITION_DURATION=150,m.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:t},m.prototype.init=function(t,e,i){if(this.enabled=!0,this.type=t,this.$element=g(e),this.options=this.getOptions(i),this.$viewport=this.options.viewport&&g(document).find(g.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var o=this.options.trigger.split(" "),n=o.length;n--;){var s=o[n];if("click"==s)this.$element.on("click."+this.type,this.options.selector,g.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",r="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,g.proxy(this.enter,this)),this.$element.on(r+"."+this.type,this.options.selector,g.proxy(this.leave,this))}}this.options.selector?this._options=g.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},m.prototype.getDefaults=function(){return m.DEFAULTS},m.prototype.getOptions=function(t){var e=this.$element.data();for(var i in e)e.hasOwnProperty(i)&&-1!==g.inArray(i,o)&&delete e[i];return(t=g.extend({},this.getDefaults(),e,t)).delay&&"number"==typeof t.delay&&(t.delay={show:t.delay,hide:t.delay}),t.sanitize&&(t.template=n(t.template,t.whiteList,t.sanitizeFn)),t},m.prototype.getDelegateOptions=function(){var i={},o=this.getDefaults();return this._options&&g.each(this._options,function(t,e){o[t]!=e&&(i[t]=e)}),i},m.prototype.enter=function(t){var e=t instanceof this.constructor?t:g(t.currentTarget).data("bs."+this.type);if(e||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e)),t instanceof g.Event&&(e.inState["focusin"==t.type?"focus":"hover"]=!0),e.tip().hasClass("in")||"in"==e.hoverState)e.hoverState="in";else{if(clearTimeout(e.timeout),e.hoverState="in",!e.options.delay||!e.options.delay.show)return e.show();e.timeout=setTimeout(function(){"in"==e.hoverState&&e.show()},e.options.delay.show)}},m.prototype.isInStateTrue=function(){for(var t in this.inState)if(this.inState[t])return!0;return!1},m.prototype.leave=function(t){var e=t instanceof this.constructor?t:g(t.currentTarget).data("bs."+this.type);if(e||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e)),t instanceof g.Event&&(e.inState["focusout"==t.type?"focus":"hover"]=!1),!e.isInStateTrue()){if(clearTimeout(e.timeout),e.hoverState="out",!e.options.delay||!e.options.delay.hide)return e.hide();e.timeout=setTimeout(function(){"out"==e.hoverState&&e.hide()},e.options.delay.hide)}},m.prototype.show=function(){var t=g.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var e=g.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!e)return;var i=this,o=this.tip(),n=this.getUID(this.type);this.setContent(),o.attr("id",n),this.$element.attr("aria-describedby",n),this.options.animation&&o.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,o[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,r=a.test(s);r&&(s=s.replace(a,"")||"top"),o.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?o.appendTo(g(document).find(this.options.container)):o.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var l=this.getPosition(),h=o[0].offsetWidth,d=o[0].offsetHeight;if(r){var p=s,c=this.getPosition(this.$viewport);s="bottom"==s&&l.bottom+d>c.bottom?"top":"top"==s&&l.top-d<c.top?"bottom":"right"==s&&l.right+h>c.width?"left":"left"==s&&l.left-h<c.left?"right":s,o.removeClass(p).addClass(s)}var f=this.getCalculatedOffset(s,l,h,d);this.applyPlacement(f,s);var u=function(){var t=i.hoverState;i.$element.trigger("shown.bs."+i.type),i.hoverState=null,"out"==t&&i.leave(i)};g.support.transition&&this.$tip.hasClass("fade")?o.one("bsTransitionEnd",u).emulateTransitionEnd(m.TRANSITION_DURATION):u()}},m.prototype.applyPlacement=function(t,e){var i=this.tip(),o=i[0].offsetWidth,n=i[0].offsetHeight,s=parseInt(i.css("margin-top"),10),a=parseInt(i.css("margin-left"),10);isNaN(s)&&(s=0),isNaN(a)&&(a=0),t.top+=s,t.left+=a,g.offset.setOffset(i[0],g.extend({using:function(t){i.css({top:Math.round(t.top),left:Math.round(t.left)})}},t),0),i.addClass("in");var r=i[0].offsetWidth,l=i[0].offsetHeight;"top"==e&&l!=n&&(t.top=t.top+n-l);var h=this.getViewportAdjustedDelta(e,t,r,l);h.left?t.left+=h.left:t.top+=h.top;var d=/top|bottom/.test(e),p=d?2*h.left-o+r:2*h.top-n+l,c=d?"offsetWidth":"offsetHeight";i.offset(t),this.replaceArrow(p,i[0][c],d)},m.prototype.replaceArrow=function(t,e,i){this.arrow().css(i?"left":"top",50*(1-t/e)+"%").css(i?"top":"left","")},m.prototype.setContent=function(){var t=this.tip(),e=this.getTitle();this.options.html?(this.options.sanitize&&(e=n(e,this.options.whiteList,this.options.sanitizeFn)),t.find(".tooltip-inner").html(e)):t.find(".tooltip-inner").text(e),t.removeClass("fade in top bottom left right")},m.prototype.hide=function(t){var e=this,i=g(this.$tip),o=g.Event("hide.bs."+this.type);function n(){"in"!=e.hoverState&&i.detach(),e.$element&&e.$element.removeAttr("aria-describedby").trigger("hidden.bs."+e.type),t&&t()}if(this.$element.trigger(o),!o.isDefaultPrevented())return i.removeClass("in"),g.support.transition&&i.hasClass("fade")?i.one("bsTransitionEnd",n).emulateTransitionEnd(m.TRANSITION_DURATION):n(),this.hoverState=null,this},m.prototype.fixTitle=function(){var t=this.$element;(t.attr("title")||"string"!=typeof t.attr("data-original-title"))&&t.attr("data-original-title",t.attr("title")||"").attr("title","")},m.prototype.hasContent=function(){return this.getTitle()},m.prototype.getPosition=function(t){var e=(t=t||this.$element)[0],i="BODY"==e.tagName,o=e.getBoundingClientRect();null==o.width&&(o=g.extend({},o,{width:o.right-o.left,height:o.bottom-o.top}));var n=window.SVGElement&&e instanceof window.SVGElement,s=i?{top:0,left:0}:n?null:t.offset(),a={scroll:i?document.documentElement.scrollTop||document.body.scrollTop:t.scrollTop()},r=i?{width:g(window).width(),height:g(window).height()}:null;return g.extend({},o,a,r,s)},m.prototype.getCalculatedOffset=function(t,e,i,o){return"bottom"==t?{top:e.top+e.height,left:e.left+e.width/2-i/2}:"top"==t?{top:e.top-o,left:e.left+e.width/2-i/2}:"left"==t?{top:e.top+e.height/2-o/2,left:e.left-i}:{top:e.top+e.height/2-o/2,left:e.left+e.width}},m.prototype.getViewportAdjustedDelta=function(t,e,i,o){var n={top:0,left:0};if(!this.$viewport)return n;var s=this.options.viewport&&this.options.viewport.padding||0,a=this.getPosition(this.$viewport);if(/right|left/.test(t)){var r=e.top-s-a.scroll,l=e.top+s-a.scroll+o;r<a.top?n.top=a.top-r:l>a.top+a.height&&(n.top=a.top+a.height-l)}else{var h=e.left-s,d=e.left+s+i;h<a.left?n.left=a.left-h:d>a.right&&(n.left=a.left+a.width-d)}return n},m.prototype.getTitle=function(){var t=this.$element,e=this.options;return t.attr("data-original-title")||("function"==typeof e.title?e.title.call(t[0]):e.title)},m.prototype.getUID=function(t){for(;t+=~~(1e6*Math.random()),document.getElementById(t););return t},m.prototype.tip=function(){if(!this.$tip&&(this.$tip=g(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},m.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},m.prototype.enable=function(){this.enabled=!0},m.prototype.disable=function(){this.enabled=!1},m.prototype.toggleEnabled=function(){this.enabled=!this.enabled},m.prototype.toggle=function(t){var e=this;t&&((e=g(t.currentTarget).data("bs."+this.type))||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e))),t?(e.inState.click=!e.inState.click,e.isInStateTrue()?e.enter(e):e.leave(e)):e.tip().hasClass("in")?e.leave(e):e.enter(e)},m.prototype.destroy=function(){var t=this;clearTimeout(this.timeout),this.hide(function(){t.$element.off("."+t.type).removeData("bs."+t.type),t.$tip&&t.$tip.detach(),t.$tip=null,t.$arrow=null,t.$viewport=null,t.$element=null})},m.prototype.sanitizeHtml=function(t){return n(t,this.options.whiteList,this.options.sanitizeFn)};var e=g.fn.tooltip;g.fn.tooltip=function i(o){return this.each(function(){var t=g(this),e=t.data("bs.tooltip"),i="object"==typeof o&&o;!e&&/destroy|hide/.test(o)||(e||t.data("bs.tooltip",e=new m(this,i)),"string"==typeof o&&e[o]())})},g.fn.tooltip.Constructor=m,g.fn.tooltip.noConflict=function(){return g.fn.tooltip=e,this}}(jQuery),function(n){"use strict";var s=function(t,e){this.init("popover",t,e)};if(!n.fn.tooltip)throw new Error("Popover requires tooltip.js");s.VERSION="3.4.1",s.DEFAULTS=n.extend({},n.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),((s.prototype=n.extend({},n.fn.tooltip.Constructor.prototype)).constructor=s).prototype.getDefaults=function(){return s.DEFAULTS},s.prototype.setContent=function(){var t=this.tip(),e=this.getTitle(),i=this.getContent();if(this.options.html){var o=typeof i;this.options.sanitize&&(e=this.sanitizeHtml(e),"string"===o&&(i=this.sanitizeHtml(i))),t.find(".popover-title").html(e),t.find(".popover-content").children().detach().end()["string"===o?"html":"append"](i)}else t.find(".popover-title").text(e),t.find(".popover-content").children().detach().end().text(i);t.removeClass("fade top bottom left right in"),t.find(".popover-title").html()||t.find(".popover-title").hide()},s.prototype.hasContent=function(){return this.getTitle()||this.getContent()},s.prototype.getContent=function(){var t=this.$element,e=this.options;return t.attr("data-content")||("function"==typeof e.content?e.content.call(t[0]):e.content)},s.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var t=n.fn.popover;n.fn.popover=function e(o){return this.each(function(){var t=n(this),e=t.data("bs.popover"),i="object"==typeof o&&o;!e&&/destroy|hide/.test(o)||(e||t.data("bs.popover",e=new s(this,i)),"string"==typeof o&&e[o]())})},n.fn.popover.Constructor=s,n.fn.popover.noConflict=function(){return n.fn.popover=t,this}}(jQuery),function(s){"use strict";function n(t,e){this.$body=s(document.body),this.$scrollElement=s(t).is(document.body)?s(window):s(t),this.options=s.extend({},n.DEFAULTS,e),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",s.proxy(this.process,this)),this.refresh(),this.process()}function e(o){return this.each(function(){var t=s(this),e=t.data("bs.scrollspy"),i="object"==typeof o&&o;e||t.data("bs.scrollspy",e=new n(this,i)),"string"==typeof o&&e[o]()})}n.VERSION="3.4.1",n.DEFAULTS={offset:10},n.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},n.prototype.refresh=function(){var t=this,o="offset",n=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),s.isWindow(this.$scrollElement[0])||(o="position",n=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map(function(){var t=s(this),e=t.data("target")||t.attr("href"),i=/^#./.test(e)&&s(e);return i&&i.length&&i.is(":visible")&&[[i[o]().top+n,e]]||null}).sort(function(t,e){return t[0]-e[0]}).each(function(){t.offsets.push(this[0]),t.targets.push(this[1])})},n.prototype.process=function(){var t,e=this.$scrollElement.scrollTop()+this.options.offset,i=this.getScrollHeight(),o=this.options.offset+i-this.$scrollElement.height(),n=this.offsets,s=this.targets,a=this.activeTarget;if(this.scrollHeight!=i&&this.refresh(),o<=e)return a!=(t=s[s.length-1])&&this.activate(t);if(a&&e<n[0])return this.activeTarget=null,this.clear();for(t=n.length;t--;)a!=s[t]&&e>=n[t]&&(n[t+1]===undefined||e<n[t+1])&&this.activate(s[t])},n.prototype.activate=function(t){this.activeTarget=t,this.clear();var e=this.selector+'[data-target="'+t+'"],'+this.selector+'[href="'+t+'"]',i=s(e).parents("li").addClass("active");i.parent(".dropdown-menu").length&&(i=i.closest("li.dropdown").addClass("active")),i.trigger("activate.bs.scrollspy")},n.prototype.clear=function(){s(this.selector).parentsUntil(this.options.target,".active").removeClass("active")};var t=s.fn.scrollspy;s.fn.scrollspy=e,s.fn.scrollspy.Constructor=n,s.fn.scrollspy.noConflict=function(){return s.fn.scrollspy=t,this},s(window).on("load.bs.scrollspy.data-api",function(){s('[data-spy="scroll"]').each(function(){var t=s(this);e.call(t,t.data())})})}(jQuery),function(r){"use strict";var a=function(t){this.element=r(t)};function e(i){return this.each(function(){var t=r(this),e=t.data("bs.tab");e||t.data("bs.tab",e=new a(this)),"string"==typeof i&&e[i]()})}a.VERSION="3.4.1",a.TRANSITION_DURATION=150,a.prototype.show=function(){var t=this.element,e=t.closest("ul:not(.dropdown-menu)"),i=t.data("target");if(i||(i=(i=t.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),!t.parent("li").hasClass("active")){var o=e.find(".active:last a"),n=r.Event("hide.bs.tab",{relatedTarget:t[0]}),s=r.Event("show.bs.tab",{relatedTarget:o[0]});if(o.trigger(n),t.trigger(s),!s.isDefaultPrevented()&&!n.isDefaultPrevented()){var a=r(document).find(i);this.activate(t.closest("li"),e),this.activate(a,a.parent(),function(){o.trigger({type:"hidden.bs.tab",relatedTarget:t[0]}),t.trigger({type:"shown.bs.tab",relatedTarget:o[0]})})}}},a.prototype.activate=function(t,e,i){var o=e.find("> .active"),n=i&&r.support.transition&&(o.length&&o.hasClass("fade")||!!e.find("> .fade").length);function s(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),t.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),n?(t[0].offsetWidth,t.addClass("in")):t.removeClass("fade"),t.parent(".dropdown-menu").length&&t.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&n?o.one("bsTransitionEnd",s).emulateTransitionEnd(a.TRANSITION_DURATION):s(),o.removeClass("in")};var t=r.fn.tab;r.fn.tab=e,r.fn.tab.Constructor=a,r.fn.tab.noConflict=function(){return r.fn.tab=t,this};var i=function(t){t.preventDefault(),e.call(r(this),"show")};r(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(l){"use strict";var h=function(t,e){this.options=l.extend({},h.DEFAULTS,e);var i=this.options.target===h.DEFAULTS.target?l(this.options.target):l(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",l.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",l.proxy(this.checkPositionWithEventLoop,this)),this.$element=l(t),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function i(o){return this.each(function(){var t=l(this),e=t.data("bs.affix"),i="object"==typeof o&&o;e||t.data("bs.affix",e=new h(this,i)),"string"==typeof o&&e[o]()})}h.VERSION="3.4.1",h.RESET="affix affix-top affix-bottom",h.DEFAULTS={offset:0,target:window},h.prototype.getState=function(t,e,i,o){var n=this.$target.scrollTop(),s=this.$element.offset(),a=this.$target.height();if(null!=i&&"top"==this.affixed)return n<i&&"top";if("bottom"==this.affixed)return null!=i?!(n+this.unpin<=s.top)&&"bottom":!(n+a<=t-o)&&"bottom";var r=null==this.affixed,l=r?n:s.top;return null!=i&&n<=i?"top":null!=o&&t-o<=l+(r?a:e)&&"bottom"},h.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(h.RESET).addClass("affix");var t=this.$target.scrollTop(),e=this.$element.offset();return this.pinnedOffset=e.top-t},h.prototype.checkPositionWithEventLoop=function(){setTimeout(l.proxy(this.checkPosition,this),1)},h.prototype.checkPosition=function(){if(this.$element.is(":visible")){var t=this.$element.height(),e=this.options.offset,i=e.top,o=e.bottom,n=Math.max(l(document).height(),l(document.body).height());"object"!=typeof e&&(o=i=e),"function"==typeof i&&(i=e.top(this.$element)),"function"==typeof o&&(o=e.bottom(this.$element));var s=this.getState(n,t,i,o);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var a="affix"+(s?"-"+s:""),r=l.Event(a+".bs.affix");if(this.$element.trigger(r),r.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(h.RESET).addClass(a).trigger(a.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:n-t-o})}};var t=l.fn.affix;l.fn.affix=i,l.fn.affix.Constructor=h,l.fn.affix.noConflict=function(){return l.fn.affix=t,this},l(window).on("load",function(){l('[data-spy="affix"]').each(function(){var t=l(this),e=t.data();e.offset=e.offset||{},null!=e.offsetBottom&&(e.offset.bottom=e.offsetBottom),null!=e.offsetTop&&(e.offset.top=e.offsetTop),i.call(t,e)})})}(jQuery);
Note: See TracChangeset for help on using the changeset viewer.