text: /*!
   * Bootstrap tooltip.js v5.0.0-beta1 (https://getbootstrap.com/)
   * Copyright 2011-2020 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   */
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined'
      ? (module.exports = factory(
          require('@popperjs/core'),
          require('./dom/data.js'),
          require('./dom/event-handler.js'),
          require('./dom/manipulator.js'),
          require('./dom/selector-engine.js')
        ))
      : typeof define === 'function' && define.amd
      ? define([
          '@popperjs/core',
          './dom/data',
          './dom/event-handler',
          './dom/manipulator',
          './dom/selector-engine',
        ], factory)
      : ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
        (global.Tooltip = factory(
          global.Popper,
          global.Data,
          global.EventHandler,
          global.Manipulator,
          global.SelectorEngine
        )));
  })(this, function (Popper, Data, EventHandler, Manipulator, SelectorEngine) {
    'use strict';
  
    function _interopDefaultLegacy(e) {
      return e && typeof e === 'object' && 'default' in e ? e : { default: e };
    }
  
    function _interopNamespace(e) {
      if (e && e.__esModule) return e;
      var n = Object.create(null);
      if (e) {
        Object.keys(e).forEach(function (k) {
          if (k !== 'default') {
            var d = Object.getOwnPropertyDescriptor(e, k);
            Object.defineProperty(
              n,
              k,
              d.get
                ? d
                : {
                    enumerable: true,
                    get: function () {
                      return e[k];
                    },
                  }
            );
          }
        });
      }
      n['default'] = e;
      return Object.freeze(n);
    }
  
    var Popper__namespace = /*#__PURE__*/ _interopNamespace(Popper);
    var Data__default = /*#__PURE__*/ _interopDefaultLegacy(Data);
    var EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
    var Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
    var SelectorEngine__default = /*#__PURE__*/ _interopDefaultLegacy(SelectorEngine);
  
    /**
     * --------------------------------------------------------------------------
     * Bootstrap (v5.0.0-beta1): util/index.js
     * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
     * --------------------------------------------------------------------------
     */
    var MAX_UID = 1000000;
    var MILLISECONDS_MULTIPLIER = 1000;
    var TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
  
    var toType = function toType(obj) {
      if (obj === null || obj === undefined) {
        return '' + obj;
      }
  
      return {}.toString
        .call(obj)
        .match(/\s([a-z]+)/i)[1]
        .toLowerCase();
    };
    /**
     * --------------------------------------------------------------------------
     * Public Util Api
     * --------------------------------------------------------------------------
     */
  
    var getUID = function getUID(prefix) {
      do {
        prefix += Math.floor(Math.random() * MAX_UID);
      } while (document.getElementById(prefix));
  
      return prefix;
    };
  
    var getTransitionDurationFromElement = function getTransitionDurationFromElement(element) {
      if (!element) {
        return 0;
      } // Get transition-duration of the element
  
      var _window$getComputedSt = window.getComputedStyle(element),
        transitionDuration = _window$getComputedSt.transitionDuration,
        transitionDelay = _window$getComputedSt.transitionDelay;
  
      var floatTransitionDuration = Number.parseFloat(transitionDuration);
      var floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
  
      if (!floatTransitionDuration && !floatTransitionDelay) {
        return 0;
      } // If multiple durations are defined, take the first
  
      transitionDuration = transitionDuration.split(',')[0];
      transitionDelay = transitionDelay.split(',')[0];
      return (
        (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) *
        MILLISECONDS_MULTIPLIER
      );
    };
  
    var triggerTransitionEnd = function triggerTransitionEnd(element) {
      element.dispatchEvent(new Event(TRANSITION_END));
    };
  
    var isElement = function isElement(obj) {
      return (obj[0] || obj).nodeType;
    };
  
    var emulateTransitionEnd = function emulateTransitionEnd(element, duration) {
      var called = false;
      var durationPadding = 5;
      var emulatedDuration = duration + durationPadding;
  
      function listener() {
        called = true;
        element.removeEventListener(TRANSITION_END, listener);
      }
  
      element.addEventListener(TRANSITION_END, listener);
      setTimeout(function () {
        if (!called) {
          triggerTransitionEnd(element);
        }
      }, emulatedDuration);
    };
  
    var typeCheckConfig = function typeCheckConfig(componentName, config, configTypes) {
      Object.keys(configTypes).forEach(function (property) {
        var expectedTypes = configTypes[property];
        var value = config[property];
        var valueType = value && isElement(value) ? 'element' : toType(value);
  
        if (!new RegExp(expectedTypes).test(valueType)) {
          throw new Error(
            componentName.toUpperCase() +
              ': ' +
              ('Option "' + property + '" provided type "' + valueType + '" ') +
              ('but expected type "' + expectedTypes + '".')
          );
        }
      });
    };
  
    var findShadowRoot = function findShadowRoot(element) {
      if (!document.documentElement.attachShadow) {
        return null;
      } // Can find the shadow root otherwise it'll return the document
  
      if (typeof element.getRootNode === 'function') {
        var root = element.getRootNode();
        return root instanceof ShadowRoot ? root : null;
      }
  
      if (element instanceof ShadowRoot) {
        return element;
      } // when we don't find a shadow root
  
      if (!element.parentNode) {
        return null;
      }
  
      return findShadowRoot(element.parentNode);
    };
  
    var noop = function noop() {
      return function () {};
    };
  
    var getjQuery = function getjQuery() {
      var _window = window,
        jQuery = _window.jQuery;
  
      if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
        return jQuery;
      }
  
      return null;
    };
  
    var onDOMContentLoaded = function onDOMContentLoaded(callback) {
      if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', callback);
      } else {
        callback();
      }
    };
  
    var isRTL = document.documentElement.dir === 'rtl';
  
    /**
     * --------------------------------------------------------------------------
     * Bootstrap (v5.0.0-beta1): util/sanitizer.js
     * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
     * --------------------------------------------------------------------------
     */
    var uriAttrs = new Set([
      'background',
      'cite',
      'href',
      'itemtype',
      'longdesc',
      'poster',
      'src',
      'xlink:href',
    ]);
    var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
    /**
     * A pattern that recognizes a commonly useful subset of URLs that are safe.
     *
     * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
     */
  
    var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/gi;
    /**
     * A pattern that matches safe data URLs. Only matches image, video and audio types.
     *
     * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
     */
  
    var 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;
  
    var allowedAttribute = function allowedAttribute(attr, allowedAttributeList) {
      var attrName = attr.nodeName.toLowerCase();
  
      if (allowedAttributeList.includes(attrName)) {
        if (uriAttrs.has(attrName)) {
          return Boolean(
            attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN)
          );
        }
  
        return true;
      }
  
      var regExp = allowedAttributeList.filter(function (attrRegex) {
        return attrRegex instanceof RegExp;
      }); // Check if a regular expression validates the attribute.
  
      for (var i = 0, len = regExp.length; i < len; i++) {
        if (attrName.match(regExp[i])) {
          return true;
        }
      }
  
      return false;
    };
  
    var DefaultAllowlist = {
      // Global attributes allowed on any supplied element below.
      '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
      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: [],
    };
    function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
      var _ref;
  
      if (!unsafeHtml.length) {
        return unsafeHtml;
      }
  
      if (sanitizeFn && typeof sanitizeFn === 'function') {
        return sanitizeFn(unsafeHtml);
      }
  
      var domParser = new window.DOMParser();
      var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
      var allowlistKeys = Object.keys(allowList);
  
      var elements = (_ref = []).concat.apply(_ref, createdDocument.body.querySelectorAll('*'));
  
      var _loop = function _loop(i, len) {
        var _ref2;
  
        var el = elements[i];
        var elName = el.nodeName.toLowerCase();
  
        if (!allowlistKeys.includes(elName)) {
          el.parentNode.removeChild(el);
          return 'continue';
        }
  
        var attributeList = (_ref2 = []).concat.apply(_ref2, el.attributes);
  
        var allowedAttributes = [].concat(allowList['*'] || [], allowList[elName] || []);
        attributeList.forEach(function (attr) {
          if (!allowedAttribute(attr, allowedAttributes)) {
            el.removeAttribute(attr.nodeName);
          }
        });
      };
  
      for (var i = 0, len = elements.length; i < len; i++) {
        var _ret = _loop(i);
  
        if (_ret === 'continue') continue;
      }
  
      return createdDocument.body.innerHTML;
    }
  
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ('value' in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    /**
     * ------------------------------------------------------------------------
     * Constants
     * ------------------------------------------------------------------------
     */
  
    var VERSION = '5.0.0-beta1';
  
    var BaseComponent = /*#__PURE__*/ (function () {
      function BaseComponent(element) {
        if (!element) {
          return;
        }
  
        this._element = element;
        Data__default['default'].setData(element, this.constructor.DATA_KEY, this);
      }
  
      var _proto = BaseComponent.prototype;
  
      _proto.dispose = function dispose() {
        Data__default['default'].removeData(this._element, this.constructor.DATA_KEY);
        this._element = null;
      };
      /** Static */
  
      BaseComponent.getInstance = function getInstance(element) {
        return Data__default['default'].getData(element, this.DATA_KEY);
      };
  
      _createClass(BaseComponent, null, [
        {
          key: 'VERSION',
          get: function get() {
            return VERSION;
          },
        },
      ]);
  
      return BaseComponent;
    })();
  
    function _extends() {
      _extends =
        Object.assign ||
        function (target) {
          for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
              if (Object.prototype.hasOwnProperty.call(source, key)) {
                target[key] = source[key];
              }
            }
          }
          return target;
        };
      return _extends.apply(this, arguments);
    }
  
    function _defineProperties$1(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ('value' in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    function _createClass$1(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties$1(Constructor, staticProps);
      return Constructor;
    }
  
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      subClass.__proto__ = superClass;
    }
    /**
     * ------------------------------------------------------------------------
     * Constants
     * ------------------------------------------------------------------------
     */
  
    var NAME = 'tooltip';
    var DATA_KEY = 'bs.tooltip';
    var EVENT_KEY = '.' + DATA_KEY;
    var CLASS_PREFIX = 'bs-tooltip';
    var BSCLS_PREFIX_REGEX = new RegExp('(^|\\s)' + CLASS_PREFIX + '\\S+', 'g');
    var DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
    var DefaultType = {
      animation: 'boolean',
      template: 'string',
      title: '(string|element|function)',
      trigger: 'string',
      delay: '(number|object)',
      html: 'boolean',
      selector: '(string|boolean)',
      placement: '(string|function)',
      container: '(string|element|boolean)',
      fallbackPlacements: '(null|array)',
      boundary: '(string|element)',
      customClass: '(string|function)',
      sanitize: 'boolean',
      sanitizeFn: '(null|function)',
      allowList: 'object',
      popperConfig: '(null|object)',
    };
    var AttachmentMap = {
      AUTO: 'auto',
      TOP: 'top',
      RIGHT: isRTL ? 'left' : 'right',
      BOTTOM: 'bottom',
      LEFT: isRTL ? 'right' : 'left',
    };
    var Default = {
      animation: true,
      template:
        '<div class="tooltip" role="tooltip">' +
        '<div class="tooltip-arrow"></div>' +
        '<div class="tooltip-inner"></div>' +
        '</div>',
      trigger: 'hover focus',
      title: '',
      delay: 0,
      html: false,
      selector: false,
      placement: 'top',
      container: false,
      fallbackPlacements: null,
      boundary: 'clippingParents',
      customClass: '',
      sanitize: true,
      sanitizeFn: null,
      allowList: DefaultAllowlist,
      popperConfig: null,
    };
    var Event$1 = {
      HIDE: 'hide' + EVENT_KEY,
      HIDDEN: 'hidden' + EVENT_KEY,
      SHOW: 'show' + EVENT_KEY,
      SHOWN: 'shown' + EVENT_KEY,
      INSERTED: 'inserted' + EVENT_KEY,
      CLICK: 'click' + EVENT_KEY,
      FOCUSIN: 'focusin' + EVENT_KEY,
      FOCUSOUT: 'focusout' + EVENT_KEY,
      MOUSEENTER: 'mouseenter' + EVENT_KEY,
      MOUSELEAVE: 'mouseleave' + EVENT_KEY,
    };
    var CLASS_NAME_FADE = 'fade';
    var CLASS_NAME_MODAL = 'modal';
    var CLASS_NAME_SHOW = 'show';
    var HOVER_STATE_SHOW = 'show';
    var HOVER_STATE_OUT = 'out';
    var SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
    var TRIGGER_HOVER = 'hover';
    var TRIGGER_FOCUS = 'focus';
    var TRIGGER_CLICK = 'click';
    var TRIGGER_MANUAL = 'manual';
    /**
     * ------------------------------------------------------------------------
     * Class Definition
     * ------------------------------------------------------------------------
     */
  
    var Tooltip = /*#__PURE__*/ (function (_BaseComponent) {
      _inheritsLoose(Tooltip, _BaseComponent);
  
      function Tooltip(element, config) {
        var _this;
  
        if (typeof Popper__namespace === 'undefined') {
          throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");
        }
  
        _this = _BaseComponent.call(this, element) || this; // private
  
        _this._isEnabled = true;
        _this._timeout = 0;
        _this._hoverState = '';
        _this._activeTrigger = {};
        _this._popper = null; // Protected
  
        _this.config = _this._getConfig(config);
        _this.tip = null;
  
        _this._setListeners();
  
        return _this;
      } // Getters
  
      var _proto = Tooltip.prototype;
  
      // Public
      _proto.enable = function enable() {
        this._isEnabled = true;
      };
  
      _proto.disable = function disable() {
        this._isEnabled = false;
      };
  
      _proto.toggleEnabled = function toggleEnabled() {
        this._isEnabled = !this._isEnabled;
      };
  
      _proto.toggle = function toggle(event) {
        if (!this._isEnabled) {
          return;
        }
  
        if (event) {
          var dataKey = this.constructor.DATA_KEY;
          var context = Data__default['default'].getData(event.delegateTarget, dataKey);
  
          if (!context) {
            context = new this.constructor(event.delegateTarget, this._getDelegateConfig());
            Data__default['default'].setData(event.delegateTarget, dataKey, context);
          }
  
          context._activeTrigger.click = !context._activeTrigger.click;
  
          if (context._isWithActiveTrigger()) {
            context._enter(null, context);
          } else {
            context._leave(null, context);
          }
        } else {
          if (this.getTipElement().classList.contains(CLASS_NAME_SHOW)) {
            this._leave(null, this);
  
            return;
          }
  
          this._enter(null, this);
        }
      };
  
      _proto.dispose = function dispose() {
        clearTimeout(this._timeout);
        EventHandler__default['default'].off(this._element, this.constructor.EVENT_KEY);
        EventHandler__default['default'].off(
          this._element.closest('.' + CLASS_NAME_MODAL),
          'hide.bs.modal',
          this._hideModalHandler
        );
  
        if (this.tip) {
          this.tip.parentNode.removeChild(this.tip);
        }
  
        this._isEnabled = null;
        this._timeout = null;
        this._hoverState = null;
        this._activeTrigger = null;
  
        if (this._popper) {
          this._popper.destroy();
        }
  
        this._popper = null;
        this.config = null;
        this.tip = null;
  
        _BaseComponent.prototype.dispose.call(this);
      };
  
      _proto.show = function show() {
        var _this2 = this;
  
        if (this._element.style.display === 'none') {
          throw new Error('Please use show on visible elements');
        }
  
        if (this.isWithContent() && this._isEnabled) {
          var showEvent = EventHandler__default['default'].trigger(
            this._element,
            this.constructor.Event.SHOW
          );
          var shadowRoot = findShadowRoot(this._element);
          var isInTheDom =
            shadowRoot === null
              ? this._element.ownerDocument.documentElement.contains(this._element)
              : shadowRoot.contains(this._element);
  
          if (showEvent.defaultPrevented || !isInTheDom) {
            return;
          }
  
          var tip = this.getTipElement();
          var tipId = getUID(this.constructor.NAME);
          tip.setAttribute('id', tipId);
  
          this._element.setAttribute('aria-describedby', tipId);
  
          this.setContent();
  
          if (this.config.animation) {
            tip.classList.add(CLASS_NAME_FADE);
          }
  
          var placement =
            typeof this.config.placement === 'function'
              ? this.config.placement.call(this, tip, this._element)
              : this.config.placement;
  
          var attachment = this._getAttachment(placement);
  
          this._addAttachmentClass(attachment);
  
          var container = this._getContainer();
  
          Data__default['default'].setData(tip, this.constructor.DATA_KEY, this);
  
          if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
            container.appendChild(tip);
          }
  
          EventHandler__default['default'].trigger(this._element, this.constructor.Event.INSERTED);
          this._popper = Popper.createPopper(this._element, tip, this._getPopperConfig(attachment));
          tip.classList.add(CLASS_NAME_SHOW);
          var customClass =
            typeof this.config.customClass === 'function'
              ? this.config.customClass()
              : this.config.customClass;
  
          if (customClass) {
            var _tip$classList;
  
            (_tip$classList = tip.classList).add.apply(_tip$classList, customClass.split(' '));
          } // If this is a touch-enabled device we add extra
          // empty mouseover listeners to the body's immediate children;
          // only needed because of broken event delegation on iOS
          // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
  
          if ('ontouchstart' in document.documentElement) {
            var _ref;
  
            (_ref = []).concat.apply(_ref, document.body.children).forEach(function (element) {
              EventHandler__default['default'].on(element, 'mouseover', noop());
            });
          }
  
          var complete = function complete() {
            var prevHoverState = _this2._hoverState;
            _this2._hoverState = null;
            EventHandler__default['default'].trigger(_this2._element, _this2.constructor.Event.SHOWN);
  
            if (prevHoverState === HOVER_STATE_OUT) {
              _this2._leave(null, _this2);
            }
          };
  
          if (this.tip.classList.contains(CLASS_NAME_FADE)) {
            var transitionDuration = getTransitionDurationFromElement(this.tip);
            EventHandler__default['default'].one(this.tip, TRANSITION_END, complete);
            emulateTransitionEnd(this.tip, transitionDuration);
          } else {
            complete();
          }
        }
      };
  
      _proto.hide = function hide() {
        var _this3 = this;
  
        if (!this._popper) {
          return;
        }
  
        var tip = this.getTipElement();
  
        var complete = function complete() {
          if (_this3._hoverState !== HOVER_STATE_SHOW && tip.parentNode) {
            tip.parentNode.removeChild(tip);
          }
  
          _this3._cleanTipClass();
  
          _this3._element.removeAttribute('aria-describedby');
  
          EventHandler__default['default'].trigger(_this3._element, _this3.constructor.Event.HIDDEN);
  
          if (_this3._popper) {
            _this3._popper.destroy();
  
            _this3._popper = null;
          }
        };
  
        var hideEvent = EventHandler__default['default'].trigger(
          this._element,
          this.constructor.Event.HIDE
        );
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        tip.classList.remove(CLASS_NAME_SHOW); // If this is a touch-enabled device we remove the extra
        // empty mouseover listeners we added for iOS support
  
        if ('ontouchstart' in document.documentElement) {
          var _ref2;
  
          (_ref2 = []).concat.apply(_ref2, document.body.children).forEach(function (element) {
            return EventHandler__default['default'].off(element, 'mouseover', noop);
          });
        }
  
        this._activeTrigger[TRIGGER_CLICK] = false;
        this._activeTrigger[TRIGGER_FOCUS] = false;
        this._activeTrigger[TRIGGER_HOVER] = false;
  
        if (this.tip.classList.contains(CLASS_NAME_FADE)) {
          var transitionDuration = getTransitionDurationFromElement(tip);
          EventHandler__default['default'].one(tip, TRANSITION_END, complete);
          emulateTransitionEnd(tip, transitionDuration);
        } else {
          complete();
        }
  
        this._hoverState = '';
      };
  
      _proto.update = function update() {
        if (this._popper !== null) {
          this._popper.update();
        }
      }; // Protected
  
      _proto.isWithContent = function isWithContent() {
        return Boolean(this.getTitle());
      };
  
      _proto.getTipElement = function getTipElement() {
        if (this.tip) {
          return this.tip;
        }
  
        var element = document.createElement('div');
        element.innerHTML = this.config.template;
        this.tip = element.children[0];
        return this.tip;
      };
  
      _proto.setContent = function setContent() {
        var tip = this.getTipElement();
        this.setElementContent(
          SelectorEngine__default['default'].findOne(SELECTOR_TOOLTIP_INNER, tip),
          this.getTitle()
        );
        tip.classList.remove(CLASS_NAME_FADE, CLASS_NAME_SHOW);
      };
  
      _proto.setElementContent = function setElementContent(element, content) {
        if (element === null) {
          return;
        }
  
        if (typeof content === 'object' && isElement(content)) {
          if (content.jquery) {
            content = content[0];
          } // content is a DOM node or a jQuery
  
          if (this.config.html) {
            if (content.parentNode !== element) {
              element.innerHTML = '';
              element.appendChild(content);
            }
          } else {
            element.textContent = content.textContent;
          }
  
          return;
        }
  
        if (this.config.html) {
          if (this.config.sanitize) {
            content = sanitizeHtml(content, this.config.allowList, this.config.sanitizeFn);
          }
  
          element.innerHTML = content;
        } else {
          element.textContent = content;
        }
      };
  
      _proto.getTitle = function getTitle() {
        var title = this._element.getAttribute('data-bs-original-title');
  
        if (!title) {
          title =
            typeof this.config.title === 'function'
              ? this.config.title.call(this._element)
              : this.config.title;
        }
  
        return title;
      };
  
      _proto.updateAttachment = function updateAttachment(attachment) {
        if (attachment === 'right') {
          return 'end';
        }
  
        if (attachment === 'left') {
          return 'start';
        }
  
        return attachment;
      }; // Private
  
      _proto._getPopperConfig = function _getPopperConfig(attachment) {
        var _this4 = this;
  
        var flipModifier = {
          name: 'flip',
          options: {
            altBoundary: true,
          },
        };
  
        if (this.config.fallbackPlacements) {
          flipModifier.options.fallbackPlacements = this.config.fallbackPlacements;
        }
  
        var defaultBsConfig = {
          placement: attachment,
          modifiers: [
            flipModifier,
            {
              name: 'preventOverflow',
              options: {
                rootBoundary: this.config.boundary,
              },
            },
            {
              name: 'arrow',
              options: {
                element: '.' + this.constructor.NAME + '-arrow',
              },
            },
            {
              name: 'onChange',
              enabled: true,
              phase: 'afterWrite',
              fn: function fn(data) {
                return _this4._handlePopperPlacementChange(data);
              },
            },
          ],
          onFirstUpdate: function onFirstUpdate(data) {
            if (data.options.placement !== data.placement) {
              _this4._handlePopperPlacementChange(data);
            }
          },
        };
        return _extends({}, defaultBsConfig, this.config.popperConfig);
      };
  
      _proto._addAttachmentClass = function _addAttachmentClass(attachment) {
        this.getTipElement().classList.add(CLASS_PREFIX + '-' + this.updateAttachment(attachment));
      };
  
      _proto._getContainer = function _getContainer() {
        if (this.config.container === false) {
          return document.body;
        }
  
        if (isElement(this.config.container)) {
          return this.config.container;
        }
  
        return SelectorEngine__default['default'].findOne(this.config.container);
      };
  
      _proto._getAttachment = function _getAttachment(placement) {
        return AttachmentMap[placement.toUpperCase()];
      };
  
      _proto._setListeners = function _setListeners() {
        var _this5 = this;
  
        var triggers = this.config.trigger.split(' ');
        triggers.forEach(function (trigger) {
          if (trigger === 'click') {
            EventHandler__default['default'].on(
              _this5._element,
              _this5.constructor.Event.CLICK,
              _this5.config.selector,
              function (event) {
                return _this5.toggle(event);
              }
            );
          } else if (trigger !== TRIGGER_MANUAL) {
            var eventIn =
              trigger === TRIGGER_HOVER
                ? _this5.constructor.Event.MOUSEENTER
                : _this5.constructor.Event.FOCUSIN;
            var eventOut =
              trigger === TRIGGER_HOVER
                ? _this5.constructor.Event.MOUSELEAVE
                : _this5.constructor.Event.FOCUSOUT;
            EventHandler__default['default'].on(
              _this5._element,
              eventIn,
              _this5.config.selector,
              function (event) {
                return _this5._enter(event);
              }
            );
            EventHandler__default['default'].on(
              _this5._element,
              eventOut,
              _this5.config.selector,
              function (event) {
                return _this5._leave(event);
              }
            );
          }
        });
  
        this._hideModalHandler = function () {
          if (_this5._element) {
            _this5.hide();
          }
        };
  
        EventHandler__default['default'].on(
          this._element.closest('.' + CLASS_NAME_MODAL),
          'hide.bs.modal',
          this._hideModalHandler
        );
  
        if (this.config.selector) {
          this.config = _extends({}, this.config, {
            trigger: 'manual',
            selector: '',
          });
        } else {
          this._fixTitle();
        }
      };
  
      _proto._fixTitle = function _fixTitle() {
        var title = this._element.getAttribute('title');
  
        var originalTitleType = typeof this._element.getAttribute('data-bs-original-title');
  
        if (title || originalTitleType !== 'string') {
          this._element.setAttribute('data-bs-original-title', title || '');
  
          if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) {
            this._element.setAttribute('aria-label', title);
          }
  
          this._element.setAttribute('title', '');
        }
      };
  
      _proto._enter = function _enter(event, context) {
        var dataKey = this.constructor.DATA_KEY;
        context = context || Data__default['default'].getData(event.delegateTarget, dataKey);
  
        if (!context) {
          context = new this.constructor(event.delegateTarget, this._getDelegateConfig());
          Data__default['default'].setData(event.delegateTarget, dataKey, context);
        }
  
        if (event) {
          context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
        }
  
        if (
          context.getTipElement().classList.contains(CLASS_NAME_SHOW) ||
          context._hoverState === HOVER_STATE_SHOW
        ) {
          context._hoverState = HOVER_STATE_SHOW;
          return;
        }
  
        clearTimeout(context._timeout);
        context._hoverState = HOVER_STATE_SHOW;
  
        if (!context.config.delay || !context.config.delay.show) {
          context.show();
          return;
        }
  
        context._timeout = setTimeout(function () {
          if (context._hoverState === HOVER_STATE_SHOW) {
            context.show();
          }
        }, context.config.delay.show);
      };
  
      _proto._leave = function _leave(event, context) {
        var dataKey = this.constructor.DATA_KEY;
        context = context || Data__default['default'].getData(event.delegateTarget, dataKey);
  
        if (!context) {
          context = new this.constructor(event.delegateTarget, this._getDelegateConfig());
          Data__default['default'].setData(event.delegateTarget, dataKey, context);
        }
  
        if (event) {
          context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false;
        }
  
        if (context._isWithActiveTrigger()) {
          return;
        }
  
        clearTimeout(context._timeout);
        context._hoverState = HOVER_STATE_OUT;
  
        if (!context.config.delay || !context.config.delay.hide) {
          context.hide();
          return;
        }
  
        context._timeout = setTimeout(function () {
          if (context._hoverState === HOVER_STATE_OUT) {
            context.hide();
          }
        }, context.config.delay.hide);
      };
  
      _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
        for (var trigger in this._activeTrigger) {
          if (this._activeTrigger[trigger]) {
            return true;
          }
        }
  
        return false;
      };
  
      _proto._getConfig = function _getConfig(config) {
        var dataAttributes = Manipulator__default['default'].getDataAttributes(this._element);
        Object.keys(dataAttributes).forEach(function (dataAttr) {
          if (DISALLOWED_ATTRIBUTES.has(dataAttr)) {
            delete dataAttributes[dataAttr];
          }
        });
  
        if (config && typeof config.container === 'object' && config.container.jquery) {
          config.container = config.container[0];
        }
  
        config = _extends(
          {},
          this.constructor.Default,
          dataAttributes,
          typeof config === 'object' && config ? config : {}
        );
  
        if (typeof config.delay === 'number') {
          config.delay = {
            show: config.delay,
            hide: config.delay,
          };
        }
  
        if (typeof config.title === 'number') {
          config.title = config.title.toString();
        }
  
        if (typeof config.content === 'number') {
          config.content = config.content.toString();
        }
  
        typeCheckConfig(NAME, config, this.constructor.DefaultType);
  
        if (config.sanitize) {
          config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn);
        }
  
        return config;
      };
  
      _proto._getDelegateConfig = function _getDelegateConfig() {
        var config = {};
  
        if (this.config) {
          for (var key in this.config) {
            if (this.constructor.Default[key] !== this.config[key]) {
              config[key] = this.config[key];
            }
          }
        }
  
        return config;
      };
  
      _proto._cleanTipClass = function _cleanTipClass() {
        var tip = this.getTipElement();
        var tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX);
  
        if (tabClass !== null && tabClass.length > 0) {
          tabClass
            .map(function (token) {
              return token.trim();
            })
            .forEach(function (tClass) {
              return tip.classList.remove(tClass);
            });
        }
      };
  
      _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
        var state = popperData.state;
  
        if (!state) {
          return;
        }
  
        this.tip = state.elements.popper;
  
        this._cleanTipClass();
  
        this._addAttachmentClass(this._getAttachment(state.placement));
      }; // Static
  
      Tooltip.jQueryInterface = function jQueryInterface(config) {
        return this.each(function () {
          var data = Data__default['default'].getData(this, DATA_KEY);
  
          var _config = typeof config === 'object' && config;
  
          if (!data && /dispose|hide/.test(config)) {
            return;
          }
  
          if (!data) {
            data = new Tooltip(this, _config);
          }
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError('No method named "' + config + '"');
            }
  
            data[config]();
          }
        });
      };
  
      _createClass$1(Tooltip, null, [
        {
          key: 'Default',
          get: function get() {
            return Default;
          },
        },
        {
          key: 'NAME',
          get: function get() {
            return NAME;
          },
        },
        {
          key: 'DATA_KEY',
          get: function get() {
            return DATA_KEY;
          },
        },
        {
          key: 'Event',
          get: function get() {
            return Event$1;
          },
        },
        {
          key: 'EVENT_KEY',
          get: function get() {
            return EVENT_KEY;
          },
        },
        {
          key: 'DefaultType',
          get: function get() {
            return DefaultType;
          },
        },
      ]);
  
      return Tooltip;
    })(BaseComponent);
    /**
     * ------------------------------------------------------------------------
     * jQuery
     * ------------------------------------------------------------------------
     * add .Tooltip to jQuery only if jQuery is present
     */
  
    onDOMContentLoaded(function () {
      var $ = getjQuery();
      /* istanbul ignore if */
  
      if ($) {
        var JQUERY_NO_CONFLICT = $.fn[NAME];
        $.fn[NAME] = Tooltip.jQueryInterface;
        $.fn[NAME].Constructor = Tooltip;
  
        $.fn[NAME].noConflict = function () {
          $.fn[NAME] = JQUERY_NO_CONFLICT;
          return Tooltip.jQueryInterface;
        };
      }
    });
  
    return Tooltip;
  });
  //# sourceMappingURL=tooltip.js.map
  