text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "/packs/";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = "./app/javascript/packs/application.js");
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "./app/javascript/channels sync recursive _channel\\.js$":
  /*!****************************************************!*\
    !*** ./app/javascript/channels sync _channel\.js$ ***!
    \****************************************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  function webpackEmptyContext(req) {
  	var e = new Error("Cannot find module '" + req + "'");
  	e.code = 'MODULE_NOT_FOUND';
  	throw e;
  }
  webpackEmptyContext.keys = function() { return []; };
  webpackEmptyContext.resolve = webpackEmptyContext;
  module.exports = webpackEmptyContext;
  webpackEmptyContext.id = "./app/javascript/channels sync recursive _channel\\.js$";
  
  /***/ }),
  
  /***/ "./app/javascript/channels/index.js":
  /*!******************************************!*\
    !*** ./app/javascript/channels/index.js ***!
    \******************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  // Load all the channels within this directory and all subdirectories.
  // Channel files must be named *_channel.js.
  var channels = __webpack_require__("./app/javascript/channels sync recursive _channel\\.js$");
  
  channels.keys().forEach(channels);
  
  /***/ }),
  
  /***/ "./app/javascript/packs/application.js":
  /*!*********************************************!*\
    !*** ./app/javascript/packs/application.js ***!
    \*********************************************/
  /*! no exports provided */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var _rails_ujs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @rails/ujs */ "./node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js");
  /* harmony import */ var _rails_ujs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_rails_ujs__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var turbolinks__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! turbolinks */ "./node_modules/turbolinks/dist/turbolinks.js");
  /* harmony import */ var turbolinks__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(turbolinks__WEBPACK_IMPORTED_MODULE_1__);
  /* harmony import */ var _rails_activestorage__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @rails/activestorage */ "./node_modules/@rails/activestorage/app/assets/javascripts/activestorage.js");
  /* harmony import */ var _rails_activestorage__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_rails_activestorage__WEBPACK_IMPORTED_MODULE_2__);
  /* harmony import */ var channels__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! channels */ "./app/javascript/channels/index.js");
  /* harmony import */ var channels__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(channels__WEBPACK_IMPORTED_MODULE_3__);
  /* harmony import */ var bootstrap__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! bootstrap */ "./node_modules/bootstrap/dist/js/bootstrap.esm.js");
  // This file is automatically compiled by Webpack, along with any other files
  // present in this directory. You're encouraged to place your actual application logic in
  // a relevant structure within app/javascript and only use these pack files to reference
  // that code so it'll be compiled.
  
  
  
  
  
  _rails_ujs__WEBPACK_IMPORTED_MODULE_0___default.a.start();
  turbolinks__WEBPACK_IMPORTED_MODULE_1___default.a.start();
  _rails_activestorage__WEBPACK_IMPORTED_MODULE_2__["start"]();
  
  /***/ }),
  
  /***/ "./node_modules/@rails/activestorage/app/assets/javascripts/activestorage.js":
  /*!***********************************************************************************!*\
    !*** ./node_modules/@rails/activestorage/app/assets/javascripts/activestorage.js ***!
    \***********************************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
  
  (function (global, factory) {
    ( false ? undefined : _typeof(exports)) === "object" && typeof module !== "undefined" ? factory(exports) :  true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : undefined;
  })(this, function (exports) {
    "use strict";
  
    function createCommonjsModule(fn, module) {
      return module = {
        exports: {}
      }, fn(module, module.exports), module.exports;
    }
  
    var sparkMd5 = createCommonjsModule(function (module, exports) {
      (function (factory) {
        {
          module.exports = factory();
        }
      })(function (undefined) {
        var hex_chr = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
  
        function md5cycle(x, k) {
          var a = x[0],
              b = x[1],
              c = x[2],
              d = x[3];
          a += (b & c | ~b & d) + k[0] - 680876936 | 0;
          a = (a << 7 | a >>> 25) + b | 0;
          d += (a & b | ~a & c) + k[1] - 389564586 | 0;
          d = (d << 12 | d >>> 20) + a | 0;
          c += (d & a | ~d & b) + k[2] + 606105819 | 0;
          c = (c << 17 | c >>> 15) + d | 0;
          b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
          b = (b << 22 | b >>> 10) + c | 0;
          a += (b & c | ~b & d) + k[4] - 176418897 | 0;
          a = (a << 7 | a >>> 25) + b | 0;
          d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
          d = (d << 12 | d >>> 20) + a | 0;
          c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
          c = (c << 17 | c >>> 15) + d | 0;
          b += (c & d | ~c & a) + k[7] - 45705983 | 0;
          b = (b << 22 | b >>> 10) + c | 0;
          a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
          a = (a << 7 | a >>> 25) + b | 0;
          d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
          d = (d << 12 | d >>> 20) + a | 0;
          c += (d & a | ~d & b) + k[10] - 42063 | 0;
          c = (c << 17 | c >>> 15) + d | 0;
          b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
          b = (b << 22 | b >>> 10) + c | 0;
          a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
          a = (a << 7 | a >>> 25) + b | 0;
          d += (a & b | ~a & c) + k[13] - 40341101 | 0;
          d = (d << 12 | d >>> 20) + a | 0;
          c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
          c = (c << 17 | c >>> 15) + d | 0;
          b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
          b = (b << 22 | b >>> 10) + c | 0;
          a += (b & d | c & ~d) + k[1] - 165796510 | 0;
          a = (a << 5 | a >>> 27) + b | 0;
          d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
          d = (d << 9 | d >>> 23) + a | 0;
          c += (d & b | a & ~b) + k[11] + 643717713 | 0;
          c = (c << 14 | c >>> 18) + d | 0;
          b += (c & a | d & ~a) + k[0] - 373897302 | 0;
          b = (b << 20 | b >>> 12) + c | 0;
          a += (b & d | c & ~d) + k[5] - 701558691 | 0;
          a = (a << 5 | a >>> 27) + b | 0;
          d += (a & c | b & ~c) + k[10] + 38016083 | 0;
          d = (d << 9 | d >>> 23) + a | 0;
          c += (d & b | a & ~b) + k[15] - 660478335 | 0;
          c = (c << 14 | c >>> 18) + d | 0;
          b += (c & a | d & ~a) + k[4] - 405537848 | 0;
          b = (b << 20 | b >>> 12) + c | 0;
          a += (b & d | c & ~d) + k[9] + 568446438 | 0;
          a = (a << 5 | a >>> 27) + b | 0;
          d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
          d = (d << 9 | d >>> 23) + a | 0;
          c += (d & b | a & ~b) + k[3] - 187363961 | 0;
          c = (c << 14 | c >>> 18) + d | 0;
          b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
          b = (b << 20 | b >>> 12) + c | 0;
          a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
          a = (a << 5 | a >>> 27) + b | 0;
          d += (a & c | b & ~c) + k[2] - 51403784 | 0;
          d = (d << 9 | d >>> 23) + a | 0;
          c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
          c = (c << 14 | c >>> 18) + d | 0;
          b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
          b = (b << 20 | b >>> 12) + c | 0;
          a += (b ^ c ^ d) + k[5] - 378558 | 0;
          a = (a << 4 | a >>> 28) + b | 0;
          d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
          d = (d << 11 | d >>> 21) + a | 0;
          c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
          c = (c << 16 | c >>> 16) + d | 0;
          b += (c ^ d ^ a) + k[14] - 35309556 | 0;
          b = (b << 23 | b >>> 9) + c | 0;
          a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
          a = (a << 4 | a >>> 28) + b | 0;
          d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
          d = (d << 11 | d >>> 21) + a | 0;
          c += (d ^ a ^ b) + k[7] - 155497632 | 0;
          c = (c << 16 | c >>> 16) + d | 0;
          b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
          b = (b << 23 | b >>> 9) + c | 0;
          a += (b ^ c ^ d) + k[13] + 681279174 | 0;
          a = (a << 4 | a >>> 28) + b | 0;
          d += (a ^ b ^ c) + k[0] - 358537222 | 0;
          d = (d << 11 | d >>> 21) + a | 0;
          c += (d ^ a ^ b) + k[3] - 722521979 | 0;
          c = (c << 16 | c >>> 16) + d | 0;
          b += (c ^ d ^ a) + k[6] + 76029189 | 0;
          b = (b << 23 | b >>> 9) + c | 0;
          a += (b ^ c ^ d) + k[9] - 640364487 | 0;
          a = (a << 4 | a >>> 28) + b | 0;
          d += (a ^ b ^ c) + k[12] - 421815835 | 0;
          d = (d << 11 | d >>> 21) + a | 0;
          c += (d ^ a ^ b) + k[15] + 530742520 | 0;
          c = (c << 16 | c >>> 16) + d | 0;
          b += (c ^ d ^ a) + k[2] - 995338651 | 0;
          b = (b << 23 | b >>> 9) + c | 0;
          a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
          a = (a << 6 | a >>> 26) + b | 0;
          d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
          d = (d << 10 | d >>> 22) + a | 0;
          c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
          c = (c << 15 | c >>> 17) + d | 0;
          b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
          b = (b << 21 | b >>> 11) + c | 0;
          a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
          a = (a << 6 | a >>> 26) + b | 0;
          d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
          d = (d << 10 | d >>> 22) + a | 0;
          c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
          c = (c << 15 | c >>> 17) + d | 0;
          b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
          b = (b << 21 | b >>> 11) + c | 0;
          a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
          a = (a << 6 | a >>> 26) + b | 0;
          d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
          d = (d << 10 | d >>> 22) + a | 0;
          c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
          c = (c << 15 | c >>> 17) + d | 0;
          b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
          b = (b << 21 | b >>> 11) + c | 0;
          a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
          a = (a << 6 | a >>> 26) + b | 0;
          d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
          d = (d << 10 | d >>> 22) + a | 0;
          c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
          c = (c << 15 | c >>> 17) + d | 0;
          b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
          b = (b << 21 | b >>> 11) + c | 0;
          x[0] = a + x[0] | 0;
          x[1] = b + x[1] | 0;
          x[2] = c + x[2] | 0;
          x[3] = d + x[3] | 0;
        }
  
        function md5blk(s) {
          var md5blks = [],
              i;
  
          for (i = 0; i < 64; i += 4) {
            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
          }
  
          return md5blks;
        }
  
        function md5blk_array(a) {
          var md5blks = [],
              i;
  
          for (i = 0; i < 64; i += 4) {
            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
          }
  
          return md5blks;
        }
  
        function md51(s) {
          var n = s.length,
              state = [1732584193, -271733879, -1732584194, 271733878],
              i,
              length,
              tail,
              tmp,
              lo,
              hi;
  
          for (i = 64; i <= n; i += 64) {
            md5cycle(state, md5blk(s.substring(i - 64, i)));
          }
  
          s = s.substring(i - 64);
          length = s.length;
          tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  
          for (i = 0; i < length; i += 1) {
            tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
          }
  
          tail[i >> 2] |= 128 << (i % 4 << 3);
  
          if (i > 55) {
            md5cycle(state, tail);
  
            for (i = 0; i < 16; i += 1) {
              tail[i] = 0;
            }
          }
  
          tmp = n * 8;
          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
          lo = parseInt(tmp[2], 16);
          hi = parseInt(tmp[1], 16) || 0;
          tail[14] = lo;
          tail[15] = hi;
          md5cycle(state, tail);
          return state;
        }
  
        function md51_array(a) {
          var n = a.length,
              state = [1732584193, -271733879, -1732584194, 271733878],
              i,
              length,
              tail,
              tmp,
              lo,
              hi;
  
          for (i = 64; i <= n; i += 64) {
            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
          }
  
          a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
          length = a.length;
          tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  
          for (i = 0; i < length; i += 1) {
            tail[i >> 2] |= a[i] << (i % 4 << 3);
          }
  
          tail[i >> 2] |= 128 << (i % 4 << 3);
  
          if (i > 55) {
            md5cycle(state, tail);
  
            for (i = 0; i < 16; i += 1) {
              tail[i] = 0;
            }
          }
  
          tmp = n * 8;
          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
          lo = parseInt(tmp[2], 16);
          hi = parseInt(tmp[1], 16) || 0;
          tail[14] = lo;
          tail[15] = hi;
          md5cycle(state, tail);
          return state;
        }
  
        function rhex(n) {
          var s = "",
              j;
  
          for (j = 0; j < 4; j += 1) {
            s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
          }
  
          return s;
        }
  
        function hex(x) {
          var i;
  
          for (i = 0; i < x.length; i += 1) {
            x[i] = rhex(x[i]);
          }
  
          return x.join("");
        }
  
        if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") ;
  
        if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
          (function () {
            function clamp(val, length) {
              val = val | 0 || 0;
  
              if (val < 0) {
                return Math.max(val + length, 0);
              }
  
              return Math.min(val, length);
            }
  
            ArrayBuffer.prototype.slice = function (from, to) {
              var length = this.byteLength,
                  begin = clamp(from, length),
                  end = length,
                  num,
                  target,
                  targetArray,
                  sourceArray;
  
              if (to !== undefined) {
                end = clamp(to, length);
              }
  
              if (begin > end) {
                return new ArrayBuffer(0);
              }
  
              num = end - begin;
              target = new ArrayBuffer(num);
              targetArray = new Uint8Array(target);
              sourceArray = new Uint8Array(this, begin, num);
              targetArray.set(sourceArray);
              return target;
            };
          })();
        }
  
        function toUtf8(str) {
          if (/[\u0080-\uFFFF]/.test(str)) {
            str = unescape(encodeURIComponent(str));
          }
  
          return str;
        }
  
        function utf8Str2ArrayBuffer(str, returnUInt8Array) {
          var length = str.length,
              buff = new ArrayBuffer(length),
              arr = new Uint8Array(buff),
              i;
  
          for (i = 0; i < length; i += 1) {
            arr[i] = str.charCodeAt(i);
          }
  
          return returnUInt8Array ? arr : buff;
        }
  
        function arrayBuffer2Utf8Str(buff) {
          return String.fromCharCode.apply(null, new Uint8Array(buff));
        }
  
        function concatenateArrayBuffers(first, second, returnUInt8Array) {
          var result = new Uint8Array(first.byteLength + second.byteLength);
          result.set(new Uint8Array(first));
          result.set(new Uint8Array(second), first.byteLength);
          return returnUInt8Array ? result : result.buffer;
        }
  
        function hexToBinaryString(hex) {
          var bytes = [],
              length = hex.length,
              x;
  
          for (x = 0; x < length - 1; x += 2) {
            bytes.push(parseInt(hex.substr(x, 2), 16));
          }
  
          return String.fromCharCode.apply(String, bytes);
        }
  
        function SparkMD5() {
          this.reset();
        }
  
        SparkMD5.prototype.append = function (str) {
          this.appendBinary(toUtf8(str));
          return this;
        };
  
        SparkMD5.prototype.appendBinary = function (contents) {
          this._buff += contents;
          this._length += contents.length;
          var length = this._buff.length,
              i;
  
          for (i = 64; i <= length; i += 64) {
            md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
          }
  
          this._buff = this._buff.substring(i - 64);
          return this;
        };
  
        SparkMD5.prototype.end = function (raw) {
          var buff = this._buff,
              length = buff.length,
              i,
              tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              ret;
  
          for (i = 0; i < length; i += 1) {
            tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
          }
  
          this._finish(tail, length);
  
          ret = hex(this._hash);
  
          if (raw) {
            ret = hexToBinaryString(ret);
          }
  
          this.reset();
          return ret;
        };
  
        SparkMD5.prototype.reset = function () {
          this._buff = "";
          this._length = 0;
          this._hash = [1732584193, -271733879, -1732584194, 271733878];
          return this;
        };
  
        SparkMD5.prototype.getState = function () {
          return {
            buff: this._buff,
            length: this._length,
            hash: this._hash
          };
        };
  
        SparkMD5.prototype.setState = function (state) {
          this._buff = state.buff;
          this._length = state.length;
          this._hash = state.hash;
          return this;
        };
  
        SparkMD5.prototype.destroy = function () {
          delete this._hash;
          delete this._buff;
          delete this._length;
        };
  
        SparkMD5.prototype._finish = function (tail, length) {
          var i = length,
              tmp,
              lo,
              hi;
          tail[i >> 2] |= 128 << (i % 4 << 3);
  
          if (i > 55) {
            md5cycle(this._hash, tail);
  
            for (i = 0; i < 16; i += 1) {
              tail[i] = 0;
            }
          }
  
          tmp = this._length * 8;
          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
          lo = parseInt(tmp[2], 16);
          hi = parseInt(tmp[1], 16) || 0;
          tail[14] = lo;
          tail[15] = hi;
          md5cycle(this._hash, tail);
        };
  
        SparkMD5.hash = function (str, raw) {
          return SparkMD5.hashBinary(toUtf8(str), raw);
        };
  
        SparkMD5.hashBinary = function (content, raw) {
          var hash = md51(content),
              ret = hex(hash);
          return raw ? hexToBinaryString(ret) : ret;
        };
  
        SparkMD5.ArrayBuffer = function () {
          this.reset();
        };
  
        SparkMD5.ArrayBuffer.prototype.append = function (arr) {
          var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
              length = buff.length,
              i;
          this._length += arr.byteLength;
  
          for (i = 64; i <= length; i += 64) {
            md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
          }
  
          this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
          return this;
        };
  
        SparkMD5.ArrayBuffer.prototype.end = function (raw) {
          var buff = this._buff,
              length = buff.length,
              tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              i,
              ret;
  
          for (i = 0; i < length; i += 1) {
            tail[i >> 2] |= buff[i] << (i % 4 << 3);
          }
  
          this._finish(tail, length);
  
          ret = hex(this._hash);
  
          if (raw) {
            ret = hexToBinaryString(ret);
          }
  
          this.reset();
          return ret;
        };
  
        SparkMD5.ArrayBuffer.prototype.reset = function () {
          this._buff = new Uint8Array(0);
          this._length = 0;
          this._hash = [1732584193, -271733879, -1732584194, 271733878];
          return this;
        };
  
        SparkMD5.ArrayBuffer.prototype.getState = function () {
          var state = SparkMD5.prototype.getState.call(this);
          state.buff = arrayBuffer2Utf8Str(state.buff);
          return state;
        };
  
        SparkMD5.ArrayBuffer.prototype.setState = function (state) {
          state.buff = utf8Str2ArrayBuffer(state.buff, true);
          return SparkMD5.prototype.setState.call(this, state);
        };
  
        SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
        SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
  
        SparkMD5.ArrayBuffer.hash = function (arr, raw) {
          var hash = md51_array(new Uint8Array(arr)),
              ret = hex(hash);
          return raw ? hexToBinaryString(ret) : ret;
        };
  
        return SparkMD5;
      });
    });
  
    var classCallCheck = function classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    };
  
    var createClass = function () {
      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);
        }
      }
  
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
  
    var fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
  
    var FileChecksum = function () {
      createClass(FileChecksum, null, [{
        key: "create",
        value: function create(file, callback) {
          var instance = new FileChecksum(file);
          instance.create(callback);
        }
      }]);
  
      function FileChecksum(file) {
        classCallCheck(this, FileChecksum);
        this.file = file;
        this.chunkSize = 2097152;
        this.chunkCount = Math.ceil(this.file.size / this.chunkSize);
        this.chunkIndex = 0;
      }
  
      createClass(FileChecksum, [{
        key: "create",
        value: function create(callback) {
          var _this = this;
  
          this.callback = callback;
          this.md5Buffer = new sparkMd5.ArrayBuffer();
          this.fileReader = new FileReader();
          this.fileReader.addEventListener("load", function (event) {
            return _this.fileReaderDidLoad(event);
          });
          this.fileReader.addEventListener("error", function (event) {
            return _this.fileReaderDidError(event);
          });
          this.readNextChunk();
        }
      }, {
        key: "fileReaderDidLoad",
        value: function fileReaderDidLoad(event) {
          this.md5Buffer.append(event.target.result);
  
          if (!this.readNextChunk()) {
            var binaryDigest = this.md5Buffer.end(true);
            var base64digest = btoa(binaryDigest);
            this.callback(null, base64digest);
          }
        }
      }, {
        key: "fileReaderDidError",
        value: function fileReaderDidError(event) {
          this.callback("Error reading " + this.file.name);
        }
      }, {
        key: "readNextChunk",
        value: function readNextChunk() {
          if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {
            var start = this.chunkIndex * this.chunkSize;
            var end = Math.min(start + this.chunkSize, this.file.size);
            var bytes = fileSlice.call(this.file, start, end);
            this.fileReader.readAsArrayBuffer(bytes);
            this.chunkIndex++;
            return true;
          } else {
            return false;
          }
        }
      }]);
      return FileChecksum;
    }();
  
    function getMetaValue(name) {
      var element = findElement(document.head, 'meta[name="' + name + '"]');
  
      if (element) {
        return element.getAttribute("content");
      }
    }
  
    function findElements(root, selector) {
      if (typeof root == "string") {
        selector = root;
        root = document;
      }
  
      var elements = root.querySelectorAll(selector);
      return toArray$1(elements);
    }
  
    function findElement(root, selector) {
      if (typeof root == "string") {
        selector = root;
        root = document;
      }
  
      return root.querySelector(selector);
    }
  
    function dispatchEvent(element, type) {
      var eventInit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      var disabled = element.disabled;
      var bubbles = eventInit.bubbles,
          cancelable = eventInit.cancelable,
          detail = eventInit.detail;
      var event = document.createEvent("Event");
      event.initEvent(type, bubbles || true, cancelable || true);
      event.detail = detail || {};
  
      try {
        element.disabled = false;
        element.dispatchEvent(event);
      } finally {
        element.disabled = disabled;
      }
  
      return event;
    }
  
    function toArray$1(value) {
      if (Array.isArray(value)) {
        return value;
      } else if (Array.from) {
        return Array.from(value);
      } else {
        return [].slice.call(value);
      }
    }
  
    var BlobRecord = function () {
      function BlobRecord(file, checksum, url) {
        var _this = this;
  
        classCallCheck(this, BlobRecord);
        this.file = file;
        this.attributes = {
          filename: file.name,
          content_type: file.type || "application/octet-stream",
          byte_size: file.size,
          checksum: checksum
        };
        this.xhr = new XMLHttpRequest();
        this.xhr.open("POST", url, true);
        this.xhr.responseType = "json";
        this.xhr.setRequestHeader("Content-Type", "application/json");
        this.xhr.setRequestHeader("Accept", "application/json");
        this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
        var csrfToken = getMetaValue("csrf-token");
  
        if (csrfToken != undefined) {
          this.xhr.setRequestHeader("X-CSRF-Token", csrfToken);
        }
  
        this.xhr.addEventListener("load", function (event) {
          return _this.requestDidLoad(event);
        });
        this.xhr.addEventListener("error", function (event) {
          return _this.requestDidError(event);
        });
      }
  
      createClass(BlobRecord, [{
        key: "create",
        value: function create(callback) {
          this.callback = callback;
          this.xhr.send(JSON.stringify({
            blob: this.attributes
          }));
        }
      }, {
        key: "requestDidLoad",
        value: function requestDidLoad(event) {
          if (this.status >= 200 && this.status < 300) {
            var response = this.response;
            var direct_upload = response.direct_upload;
            delete response.direct_upload;
            this.attributes = response;
            this.directUploadData = direct_upload;
            this.callback(null, this.toJSON());
          } else {
            this.requestDidError(event);
          }
        }
      }, {
        key: "requestDidError",
        value: function requestDidError(event) {
          this.callback('Error creating Blob for "' + this.file.name + '". Status: ' + this.status);
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          var result = {};
  
          for (var key in this.attributes) {
            result[key] = this.attributes[key];
          }
  
          return result;
        }
      }, {
        key: "status",
        get: function get$$1() {
          return this.xhr.status;
        }
      }, {
        key: "response",
        get: function get$$1() {
          var _xhr = this.xhr,
              responseType = _xhr.responseType,
              response = _xhr.response;
  
          if (responseType == "json") {
            return response;
          } else {
            return JSON.parse(response);
          }
        }
      }]);
      return BlobRecord;
    }();
  
    var BlobUpload = function () {
      function BlobUpload(blob) {
        var _this = this;
  
        classCallCheck(this, BlobUpload);
        this.blob = blob;
        this.file = blob.file;
        var _blob$directUploadDat = blob.directUploadData,
            url = _blob$directUploadDat.url,
            headers = _blob$directUploadDat.headers;
        this.xhr = new XMLHttpRequest();
        this.xhr.open("PUT", url, true);
        this.xhr.responseType = "text";
  
        for (var key in headers) {
          this.xhr.setRequestHeader(key, headers[key]);
        }
  
        this.xhr.addEventListener("load", function (event) {
          return _this.requestDidLoad(event);
        });
        this.xhr.addEventListener("error", function (event) {
          return _this.requestDidError(event);
        });
      }
  
      createClass(BlobUpload, [{
        key: "create",
        value: function create(callback) {
          this.callback = callback;
          this.xhr.send(this.file.slice());
        }
      }, {
        key: "requestDidLoad",
        value: function requestDidLoad(event) {
          var _xhr = this.xhr,
              status = _xhr.status,
              response = _xhr.response;
  
          if (status >= 200 && status < 300) {
            this.callback(null, response);
          } else {
            this.requestDidError(event);
          }
        }
      }, {
        key: "requestDidError",
        value: function requestDidError(event) {
          this.callback('Error storing "' + this.file.name + '". Status: ' + this.xhr.status);
        }
      }]);
      return BlobUpload;
    }();
  
    var id = 0;
  
    var DirectUpload = function () {
      function DirectUpload(file, url, delegate) {
        classCallCheck(this, DirectUpload);
        this.id = ++id;
        this.file = file;
        this.url = url;
        this.delegate = delegate;
      }
  
      createClass(DirectUpload, [{
        key: "create",
        value: function create(callback) {
          var _this = this;
  
          FileChecksum.create(this.file, function (error, checksum) {
            if (error) {
              callback(error);
              return;
            }
  
            var blob = new BlobRecord(_this.file, checksum, _this.url);
            notify(_this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr);
            blob.create(function (error) {
              if (error) {
                callback(error);
              } else {
                var upload = new BlobUpload(blob);
                notify(_this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr);
                upload.create(function (error) {
                  if (error) {
                    callback(error);
                  } else {
                    callback(null, blob.toJSON());
                  }
                });
              }
            });
          });
        }
      }]);
      return DirectUpload;
    }();
  
    function notify(object, methodName) {
      if (object && typeof object[methodName] == "function") {
        for (var _len = arguments.length, messages = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
          messages[_key - 2] = arguments[_key];
        }
  
        return object[methodName].apply(object, messages);
      }
    }
  
    var DirectUploadController = function () {
      function DirectUploadController(input, file) {
        classCallCheck(this, DirectUploadController);
        this.input = input;
        this.file = file;
        this.directUpload = new DirectUpload(this.file, this.url, this);
        this.dispatch("initialize");
      }
  
      createClass(DirectUploadController, [{
        key: "start",
        value: function start(callback) {
          var _this = this;
  
          var hiddenInput = document.createElement("input");
          hiddenInput.type = "hidden";
          hiddenInput.name = this.input.name;
          this.input.insertAdjacentElement("beforebegin", hiddenInput);
          this.dispatch("start");
          this.directUpload.create(function (error, attributes) {
            if (error) {
              hiddenInput.parentNode.removeChild(hiddenInput);
  
              _this.dispatchError(error);
            } else {
              hiddenInput.value = attributes.signed_id;
            }
  
            _this.dispatch("end");
  
            callback(error);
          });
        }
      }, {
        key: "uploadRequestDidProgress",
        value: function uploadRequestDidProgress(event) {
          var progress = event.loaded / event.total * 100;
  
          if (progress) {
            this.dispatch("progress", {
              progress: progress
            });
          }
        }
      }, {
        key: "dispatch",
        value: function dispatch(name) {
          var detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          detail.file = this.file;
          detail.id = this.directUpload.id;
          return dispatchEvent(this.input, "direct-upload:" + name, {
            detail: detail
          });
        }
      }, {
        key: "dispatchError",
        value: function dispatchError(error) {
          var event = this.dispatch("error", {
            error: error
          });
  
          if (!event.defaultPrevented) {
            alert(error);
          }
        }
      }, {
        key: "directUploadWillCreateBlobWithXHR",
        value: function directUploadWillCreateBlobWithXHR(xhr) {
          this.dispatch("before-blob-request", {
            xhr: xhr
          });
        }
      }, {
        key: "directUploadWillStoreFileWithXHR",
        value: function directUploadWillStoreFileWithXHR(xhr) {
          var _this2 = this;
  
          this.dispatch("before-storage-request", {
            xhr: xhr
          });
          xhr.upload.addEventListener("progress", function (event) {
            return _this2.uploadRequestDidProgress(event);
          });
        }
      }, {
        key: "url",
        get: function get$$1() {
          return this.input.getAttribute("data-direct-upload-url");
        }
      }]);
      return DirectUploadController;
    }();
  
    var inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])";
  
    var DirectUploadsController = function () {
      function DirectUploadsController(form) {
        classCallCheck(this, DirectUploadsController);
        this.form = form;
        this.inputs = findElements(form, inputSelector).filter(function (input) {
          return input.files.length;
        });
      }
  
      createClass(DirectUploadsController, [{
        key: "start",
        value: function start(callback) {
          var _this = this;
  
          var controllers = this.createDirectUploadControllers();
  
          var startNextController = function startNextController() {
            var controller = controllers.shift();
  
            if (controller) {
              controller.start(function (error) {
                if (error) {
                  callback(error);
  
                  _this.dispatch("end");
                } else {
                  startNextController();
                }
              });
            } else {
              callback();
  
              _this.dispatch("end");
            }
          };
  
          this.dispatch("start");
          startNextController();
        }
      }, {
        key: "createDirectUploadControllers",
        value: function createDirectUploadControllers() {
          var controllers = [];
          this.inputs.forEach(function (input) {
            toArray$1(input.files).forEach(function (file) {
              var controller = new DirectUploadController(input, file);
              controllers.push(controller);
            });
          });
          return controllers;
        }
      }, {
        key: "dispatch",
        value: function dispatch(name) {
          var detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return dispatchEvent(this.form, "direct-uploads:" + name, {
            detail: detail
          });
        }
      }]);
      return DirectUploadsController;
    }();
  
    var processingAttribute = "data-direct-uploads-processing";
    var submitButtonsByForm = new WeakMap();
    var started = false;
  
    function start() {
      if (!started) {
        started = true;
        document.addEventListener("click", didClick, true);
        document.addEventListener("submit", didSubmitForm);
        document.addEventListener("ajax:before", didSubmitRemoteElement);
      }
    }
  
    function didClick(event) {
      var target = event.target;
  
      if ((target.tagName == "INPUT" || target.tagName == "BUTTON") && target.type == "submit" && target.form) {
        submitButtonsByForm.set(target.form, target);
      }
    }
  
    function didSubmitForm(event) {
      handleFormSubmissionEvent(event);
    }
  
    function didSubmitRemoteElement(event) {
      if (event.target.tagName == "FORM") {
        handleFormSubmissionEvent(event);
      }
    }
  
    function handleFormSubmissionEvent(event) {
      var form = event.target;
  
      if (form.hasAttribute(processingAttribute)) {
        event.preventDefault();
        return;
      }
  
      var controller = new DirectUploadsController(form);
      var inputs = controller.inputs;
  
      if (inputs.length) {
        event.preventDefault();
        form.setAttribute(processingAttribute, "");
        inputs.forEach(disable);
        controller.start(function (error) {
          form.removeAttribute(processingAttribute);
  
          if (error) {
            inputs.forEach(enable);
          } else {
            submitForm(form);
          }
        });
      }
    }
  
    function submitForm(form) {
      var button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]");
  
      if (button) {
        var _button = button,
            disabled = _button.disabled;
        button.disabled = false;
        button.focus();
        button.click();
        button.disabled = disabled;
      } else {
        button = document.createElement("input");
        button.type = "submit";
        button.style.display = "none";
        form.appendChild(button);
        button.click();
        form.removeChild(button);
      }
  
      submitButtonsByForm.delete(form);
    }
  
    function disable(input) {
      input.disabled = true;
    }
  
    function enable(input) {
      input.disabled = false;
    }
  
    function autostart() {
      if (window.ActiveStorage) {
        start();
      }
    }
  
    setTimeout(autostart, 1);
    exports.start = start;
    exports.DirectUpload = DirectUpload;
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
  });
  
  /***/ }),
  
  /***/ "./node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js":
  /*!******************************************************************!*\
    !*** ./node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js ***!
    \******************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
  
  /*
  Unobtrusive JavaScript
  https://github.com/rails/rails/blob/main/actionview/app/assets/javascripts
  Released under the MIT license
   */
  ;
  (function () {
    var context = this;
    (function () {
      (function () {
        this.Rails = {
          linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
          buttonClickSelector: {
            selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',
            exclude: 'form button'
          },
          inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
          formSubmitSelector: 'form:not([data-turbo=true])',
          formInputClickSelector: 'form:not([data-turbo=true]) input[type=submit], form:not([data-turbo=true]) input[type=image], form:not([data-turbo=true]) button[type=submit], form:not([data-turbo=true]) button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
          formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
          formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
          fileInputSelector: 'input[name][type=file]:not([disabled])',
          linkDisableSelector: 'a[data-disable-with], a[data-disable]',
          buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
        };
      }).call(this);
    }).call(context);
    var Rails = context.Rails;
    (function () {
      (function () {
        var nonce;
        nonce = null;
  
        Rails.loadCSPNonce = function () {
          var ref;
          return nonce = (ref = document.querySelector("meta[name=csp-nonce]")) != null ? ref.content : void 0;
        };
  
        Rails.cspNonce = function () {
          return nonce != null ? nonce : Rails.loadCSPNonce();
        };
      }).call(this);
      (function () {
        var expando, m;
        m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
  
        Rails.matches = function (element, selector) {
          if (selector.exclude != null) {
            return m.call(element, selector.selector) && !m.call(element, selector.exclude);
          } else {
            return m.call(element, selector);
          }
        };
  
        expando = '_ujsData';
  
        Rails.getData = function (element, key) {
          var ref;
          return (ref = element[expando]) != null ? ref[key] : void 0;
        };
  
        Rails.setData = function (element, key, value) {
          if (element[expando] == null) {
            element[expando] = {};
          }
  
          return element[expando][key] = value;
        };
  
        Rails.$ = function (selector) {
          return Array.prototype.slice.call(document.querySelectorAll(selector));
        };
      }).call(this);
      (function () {
        var $, csrfParam, csrfToken;
        $ = Rails.$;
  
        csrfToken = Rails.csrfToken = function () {
          var meta;
          meta = document.querySelector('meta[name=csrf-token]');
          return meta && meta.content;
        };
  
        csrfParam = Rails.csrfParam = function () {
          var meta;
          meta = document.querySelector('meta[name=csrf-param]');
          return meta && meta.content;
        };
  
        Rails.CSRFProtection = function (xhr) {
          var token;
          token = csrfToken();
  
          if (token != null) {
            return xhr.setRequestHeader('X-CSRF-Token', token);
          }
        };
  
        Rails.refreshCSRFTokens = function () {
          var param, token;
          token = csrfToken();
          param = csrfParam();
  
          if (token != null && param != null) {
            return $('form input[name="' + param + '"]').forEach(function (input) {
              return input.value = token;
            });
          }
        };
      }).call(this);
      (function () {
        var CustomEvent, fire, matches, preventDefault;
        matches = Rails.matches;
        CustomEvent = window.CustomEvent;
  
        if (typeof CustomEvent !== 'function') {
          CustomEvent = function CustomEvent(event, params) {
            var evt;
            evt = document.createEvent('CustomEvent');
            evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
            return evt;
          };
  
          CustomEvent.prototype = window.Event.prototype;
          preventDefault = CustomEvent.prototype.preventDefault;
  
          CustomEvent.prototype.preventDefault = function () {
            var result;
            result = preventDefault.call(this);
  
            if (this.cancelable && !this.defaultPrevented) {
              Object.defineProperty(this, 'defaultPrevented', {
                get: function get() {
                  return true;
                }
              });
            }
  
            return result;
          };
        }
  
        fire = Rails.fire = function (obj, name, data) {
          var event;
          event = new CustomEvent(name, {
            bubbles: true,
            cancelable: true,
            detail: data
          });
          obj.dispatchEvent(event);
          return !event.defaultPrevented;
        };
  
        Rails.stopEverything = function (e) {
          fire(e.target, 'ujs:everythingStopped');
          e.preventDefault();
          e.stopPropagation();
          return e.stopImmediatePropagation();
        };
  
        Rails.delegate = function (element, selector, eventType, handler) {
          return element.addEventListener(eventType, function (e) {
            var target;
            target = e.target;
  
            while (!(!(target instanceof Element) || matches(target, selector))) {
              target = target.parentNode;
            }
  
            if (target instanceof Element && handler.call(target, e) === false) {
              e.preventDefault();
              return e.stopPropagation();
            }
          });
        };
      }).call(this);
      (function () {
        var AcceptHeaders, CSRFProtection, createXHR, cspNonce, fire, prepareOptions, processResponse;
        cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;
        AcceptHeaders = {
          '*': '*/*',
          text: 'text/plain',
          html: 'text/html',
          xml: 'application/xml, text/xml',
          json: 'application/json, text/javascript',
          script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
        };
  
        Rails.ajax = function (options) {
          var xhr;
          options = prepareOptions(options);
          xhr = createXHR(options, function () {
            var ref, response;
            response = processResponse((ref = xhr.response) != null ? ref : xhr.responseText, xhr.getResponseHeader('Content-Type'));
  
            if (Math.floor(xhr.status / 100) === 2) {
              if (typeof options.success === "function") {
                options.success(response, xhr.statusText, xhr);
              }
            } else {
              if (typeof options.error === "function") {
                options.error(response, xhr.statusText, xhr);
              }
            }
  
            return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : void 0;
          });
  
          if (options.beforeSend != null && !options.beforeSend(xhr, options)) {
            return false;
          }
  
          if (xhr.readyState === XMLHttpRequest.OPENED) {
            return xhr.send(options.data);
          }
        };
  
        prepareOptions = function prepareOptions(options) {
          options.url = options.url || location.href;
          options.type = options.type.toUpperCase();
  
          if (options.type === 'GET' && options.data) {
            if (options.url.indexOf('?') < 0) {
              options.url += '?' + options.data;
            } else {
              options.url += '&' + options.data;
            }
          }
  
          if (AcceptHeaders[options.dataType] == null) {
            options.dataType = '*';
          }
  
          options.accept = AcceptHeaders[options.dataType];
  
          if (options.dataType !== '*') {
            options.accept += ', */*; q=0.01';
          }
  
          return options;
        };
  
        createXHR = function createXHR(options, done) {
          var xhr;
          xhr = new XMLHttpRequest();
          xhr.open(options.type, options.url, true);
          xhr.setRequestHeader('Accept', options.accept);
  
          if (typeof options.data === 'string') {
            xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
          }
  
          if (!options.crossDomain) {
            xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
            CSRFProtection(xhr);
          }
  
          xhr.withCredentials = !!options.withCredentials;
  
          xhr.onreadystatechange = function () {
            if (xhr.readyState === XMLHttpRequest.DONE) {
              return done(xhr);
            }
          };
  
          return xhr;
        };
  
        processResponse = function processResponse(response, type) {
          var parser, script;
  
          if (typeof response === 'string' && typeof type === 'string') {
            if (type.match(/\bjson\b/)) {
              try {
                response = JSON.parse(response);
              } catch (error) {}
            } else if (type.match(/\b(?:java|ecma)script\b/)) {
              script = document.createElement('script');
              script.setAttribute('nonce', cspNonce());
              script.text = response;
              document.head.appendChild(script).parentNode.removeChild(script);
            } else if (type.match(/\b(xml|html|svg)\b/)) {
              parser = new DOMParser();
              type = type.replace(/;.+/, '');
  
              try {
                response = parser.parseFromString(response, type);
              } catch (error) {}
            }
          }
  
          return response;
        };
  
        Rails.href = function (element) {
          return element.href;
        };
  
        Rails.isCrossDomain = function (url) {
          var e, originAnchor, urlAnchor;
          originAnchor = document.createElement('a');
          originAnchor.href = location.href;
          urlAnchor = document.createElement('a');
  
          try {
            urlAnchor.href = url;
            return !((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host || originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host);
          } catch (error) {
            e = error;
            return true;
          }
        };
      }).call(this);
      (function () {
        var matches, toArray;
        matches = Rails.matches;
  
        toArray = function toArray(e) {
          return Array.prototype.slice.call(e);
        };
  
        Rails.serializeElement = function (element, additionalParam) {
          var inputs, params;
          inputs = [element];
  
          if (matches(element, 'form')) {
            inputs = toArray(element.elements);
          }
  
          params = [];
          inputs.forEach(function (input) {
            if (!input.name || input.disabled) {
              return;
            }
  
            if (matches(input, 'fieldset[disabled] *')) {
              return;
            }
  
            if (matches(input, 'select')) {
              return toArray(input.options).forEach(function (option) {
                if (option.selected) {
                  return params.push({
                    name: input.name,
                    value: option.value
                  });
                }
              });
            } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {
              return params.push({
                name: input.name,
                value: input.value
              });
            }
          });
  
          if (additionalParam) {
            params.push(additionalParam);
          }
  
          return params.map(function (param) {
            if (param.name != null) {
              return encodeURIComponent(param.name) + "=" + encodeURIComponent(param.value);
            } else {
              return param;
            }
          }).join('&');
        };
  
        Rails.formElements = function (form, selector) {
          if (matches(form, 'form')) {
            return toArray(form.elements).filter(function (el) {
              return matches(el, selector);
            });
          } else {
            return toArray(form.querySelectorAll(selector));
          }
        };
      }).call(this);
      (function () {
        var allowAction, fire, stopEverything;
        fire = Rails.fire, stopEverything = Rails.stopEverything;
  
        Rails.handleConfirm = function (e) {
          if (!allowAction(this)) {
            return stopEverything(e);
          }
        };
  
        Rails.confirm = function (message, element) {
          return confirm(message);
        };
  
        allowAction = function allowAction(element) {
          var answer, callback, message;
          message = element.getAttribute('data-confirm');
  
          if (!message) {
            return true;
          }
  
          answer = false;
  
          if (fire(element, 'confirm')) {
            try {
              answer = Rails.confirm(message, element);
            } catch (error) {}
  
            callback = fire(element, 'confirm:complete', [answer]);
          }
  
          return answer && callback;
        };
      }).call(this);
      (function () {
        var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, isXhrRedirect, matches, setData, stopEverything;
        matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;
  
        Rails.handleDisabledElement = function (e) {
          var element;
          element = this;
  
          if (element.disabled) {
            return stopEverything(e);
          }
        };
  
        Rails.enableElement = function (e) {
          var element;
  
          if (e instanceof Event) {
            if (isXhrRedirect(e)) {
              return;
            }
  
            element = e.target;
          } else {
            element = e;
          }
  
          if (matches(element, Rails.linkDisableSelector)) {
            return enableLinkElement(element);
          } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {
            return enableFormElement(element);
          } else if (matches(element, Rails.formSubmitSelector)) {
            return enableFormElements(element);
          }
        };
  
        Rails.disableElement = function (e) {
          var element;
          element = e instanceof Event ? e.target : e;
  
          if (matches(element, Rails.linkDisableSelector)) {
            return disableLinkElement(element);
          } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {
            return disableFormElement(element);
          } else if (matches(element, Rails.formSubmitSelector)) {
            return disableFormElements(element);
          }
        };
  
        disableLinkElement = function disableLinkElement(element) {
          var replacement;
  
          if (getData(element, 'ujs:disabled')) {
            return;
          }
  
          replacement = element.getAttribute('data-disable-with');
  
          if (replacement != null) {
            setData(element, 'ujs:enable-with', element.innerHTML);
            element.innerHTML = replacement;
          }
  
          element.addEventListener('click', stopEverything);
          return setData(element, 'ujs:disabled', true);
        };
  
        enableLinkElement = function enableLinkElement(element) {
          var originalText;
          originalText = getData(element, 'ujs:enable-with');
  
          if (originalText != null) {
            element.innerHTML = originalText;
            setData(element, 'ujs:enable-with', null);
          }
  
          element.removeEventListener('click', stopEverything);
          return setData(element, 'ujs:disabled', null);
        };
  
        disableFormElements = function disableFormElements(form) {
          return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);
        };
  
        disableFormElement = function disableFormElement(element) {
          var replacement;
  
          if (getData(element, 'ujs:disabled')) {
            return;
          }
  
          replacement = element.getAttribute('data-disable-with');
  
          if (replacement != null) {
            if (matches(element, 'button')) {
              setData(element, 'ujs:enable-with', element.innerHTML);
              element.innerHTML = replacement;
            } else {
              setData(element, 'ujs:enable-with', element.value);
              element.value = replacement;
            }
          }
  
          element.disabled = true;
          return setData(element, 'ujs:disabled', true);
        };
  
        enableFormElements = function enableFormElements(form) {
          return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);
        };
  
        enableFormElement = function enableFormElement(element) {
          var originalText;
          originalText = getData(element, 'ujs:enable-with');
  
          if (originalText != null) {
            if (matches(element, 'button')) {
              element.innerHTML = originalText;
            } else {
              element.value = originalText;
            }
  
            setData(element, 'ujs:enable-with', null);
          }
  
          element.disabled = false;
          return setData(element, 'ujs:disabled', null);
        };
  
        isXhrRedirect = function isXhrRedirect(event) {
          var ref, xhr;
          xhr = (ref = event.detail) != null ? ref[0] : void 0;
          return (xhr != null ? xhr.getResponseHeader("X-Xhr-Redirect") : void 0) != null;
        };
      }).call(this);
      (function () {
        var stopEverything;
        stopEverything = Rails.stopEverything;
  
        Rails.handleMethod = function (e) {
          var csrfParam, csrfToken, form, formContent, href, link, method;
          link = this;
          method = link.getAttribute('data-method');
  
          if (!method) {
            return;
          }
  
          href = Rails.href(link);
          csrfToken = Rails.csrfToken();
          csrfParam = Rails.csrfParam();
          form = document.createElement('form');
          formContent = "<input name='_method' value='" + method + "' type='hidden' />";
  
          if (csrfParam != null && csrfToken != null && !Rails.isCrossDomain(href)) {
            formContent += "<input name='" + csrfParam + "' value='" + csrfToken + "' type='hidden' />";
          }
  
          formContent += '<input type="submit" />';
          form.method = 'post';
          form.action = href;
          form.target = link.target;
          form.innerHTML = formContent;
          form.style.display = 'none';
          document.body.appendChild(form);
          form.querySelector('[type="submit"]').click();
          return stopEverything(e);
        };
      }).call(this);
      (function () {
        var ajax,
            fire,
            getData,
            isCrossDomain,
            isRemote,
            matches,
            serializeElement,
            setData,
            stopEverything,
            slice = [].slice;
        matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;
  
        isRemote = function isRemote(element) {
          var value;
          value = element.getAttribute('data-remote');
          return value != null && value !== 'false';
        };
  
        Rails.handleRemote = function (e) {
          var button, data, dataType, element, method, url, withCredentials;
          element = this;
  
          if (!isRemote(element)) {
            return true;
          }
  
          if (!fire(element, 'ajax:before')) {
            fire(element, 'ajax:stopped');
            return false;
          }
  
          withCredentials = element.getAttribute('data-with-credentials');
          dataType = element.getAttribute('data-type') || 'script';
  
          if (matches(element, Rails.formSubmitSelector)) {
            button = getData(element, 'ujs:submit-button');
            method = getData(element, 'ujs:submit-button-formmethod') || element.method;
            url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;
  
            if (method.toUpperCase() === 'GET') {
              url = url.replace(/\?.*$/, '');
            }
  
            if (element.enctype === 'multipart/form-data') {
              data = new FormData(element);
  
              if (button != null) {
                data.append(button.name, button.value);
              }
            } else {
              data = serializeElement(element, button);
            }
  
            setData(element, 'ujs:submit-button', null);
            setData(element, 'ujs:submit-button-formmethod', null);
            setData(element, 'ujs:submit-button-formaction', null);
          } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {
            method = element.getAttribute('data-method');
            url = element.getAttribute('data-url');
            data = serializeElement(element, element.getAttribute('data-params'));
          } else {
            method = element.getAttribute('data-method');
            url = Rails.href(element);
            data = element.getAttribute('data-params');
          }
  
          ajax({
            type: method || 'GET',
            url: url,
            data: data,
            dataType: dataType,
            beforeSend: function beforeSend(xhr, options) {
              if (fire(element, 'ajax:beforeSend', [xhr, options])) {
                return fire(element, 'ajax:send', [xhr]);
              } else {
                fire(element, 'ajax:stopped');
                return false;
              }
            },
            success: function success() {
              var args;
              args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
              return fire(element, 'ajax:success', args);
            },
            error: function error() {
              var args;
              args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
              return fire(element, 'ajax:error', args);
            },
            complete: function complete() {
              var args;
              args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
              return fire(element, 'ajax:complete', args);
            },
            crossDomain: isCrossDomain(url),
            withCredentials: withCredentials != null && withCredentials !== 'false'
          });
          return stopEverything(e);
        };
  
        Rails.formSubmitButtonClick = function (e) {
          var button, form;
          button = this;
          form = button.form;
  
          if (!form) {
            return;
          }
  
          if (button.name) {
            setData(form, 'ujs:submit-button', {
              name: button.name,
              value: button.value
            });
          }
  
          setData(form, 'ujs:formnovalidate-button', button.formNoValidate);
          setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));
          return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));
        };
  
        Rails.preventInsignificantClick = function (e) {
          var data, insignificantMetaClick, link, metaClick, method, nonPrimaryMouseClick;
          link = this;
          method = (link.getAttribute('data-method') || 'GET').toUpperCase();
          data = link.getAttribute('data-params');
          metaClick = e.metaKey || e.ctrlKey;
          insignificantMetaClick = metaClick && method === 'GET' && !data;
          nonPrimaryMouseClick = e.button != null && e.button !== 0;
  
          if (nonPrimaryMouseClick || insignificantMetaClick) {
            return e.stopImmediatePropagation();
          }
        };
      }).call(this);
      (function () {
        var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMethod, handleRemote, loadCSPNonce, preventInsignificantClick, refreshCSRFTokens;
        fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, loadCSPNonce = Rails.loadCSPNonce, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, preventInsignificantClick = Rails.preventInsignificantClick, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMethod = Rails.handleMethod;
  
        if (typeof jQuery !== "undefined" && jQuery !== null && jQuery.ajax != null) {
          if (jQuery.rails) {
            throw new Error('If you load both jquery_ujs and rails-ujs, use rails-ujs only.');
          }
  
          jQuery.rails = Rails;
          jQuery.ajaxPrefilter(function (options, originalOptions, xhr) {
            if (!options.crossDomain) {
              return CSRFProtection(xhr);
            }
          });
        }
  
        Rails.start = function () {
          if (window._rails_loaded) {
            throw new Error('rails-ujs has already been loaded!');
          }
  
          window.addEventListener('pageshow', function () {
            $(Rails.formEnableSelector).forEach(function (el) {
              if (getData(el, 'ujs:disabled')) {
                return enableElement(el);
              }
            });
            return $(Rails.linkDisableSelector).forEach(function (el) {
              if (getData(el, 'ujs:disabled')) {
                return enableElement(el);
              }
            });
          });
          delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);
          delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);
          delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);
          delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);
          delegate(document, Rails.linkClickSelector, 'click', preventInsignificantClick);
          delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);
          delegate(document, Rails.linkClickSelector, 'click', handleConfirm);
          delegate(document, Rails.linkClickSelector, 'click', disableElement);
          delegate(document, Rails.linkClickSelector, 'click', handleRemote);
          delegate(document, Rails.linkClickSelector, 'click', handleMethod);
          delegate(document, Rails.buttonClickSelector, 'click', preventInsignificantClick);
          delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);
          delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);
          delegate(document, Rails.buttonClickSelector, 'click', disableElement);
          delegate(document, Rails.buttonClickSelector, 'click', handleRemote);
          delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);
          delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);
          delegate(document, Rails.inputChangeSelector, 'change', handleRemote);
          delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);
          delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);
          delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);
          delegate(document, Rails.formSubmitSelector, 'submit', function (e) {
            return setTimeout(function () {
              return disableElement(e);
            }, 13);
          });
          delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);
          delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);
          delegate(document, Rails.formInputClickSelector, 'click', preventInsignificantClick);
          delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);
          delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);
          delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);
          document.addEventListener('DOMContentLoaded', refreshCSRFTokens);
          document.addEventListener('DOMContentLoaded', loadCSPNonce);
          return window._rails_loaded = true;
        };
  
        if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {
          Rails.start();
        }
      }).call(this);
    }).call(this);
  
    if (( false ? undefined : _typeof(module)) === "object" && module.exports) {
      module.exports = Rails;
    } else if (true) {
      !(__WEBPACK_AMD_DEFINE_FACTORY__ = (Rails),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
  				__WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
    }
  }).call(this);
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module)))
  
  /***/ }),
  
  /***/ "./node_modules/bootstrap/dist/js/bootstrap.esm.js":
  /*!*********************************************************!*\
    !*** ./node_modules/bootstrap/dist/js/bootstrap.esm.js ***!
    \*********************************************************/
  /*! exports provided: Alert, Button, Carousel, Collapse, Dropdown, Modal, Offcanvas, Popover, ScrollSpy, Tab, Toast, Tooltip */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Alert", function() { return Alert; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Button", function() { return Button; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Carousel", function() { return Carousel; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Collapse", function() { return Collapse; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Dropdown", function() { return Dropdown; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Modal", function() { return Modal; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Offcanvas", function() { return Offcanvas; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Popover", function() { return Popover; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ScrollSpy", function() { return ScrollSpy; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tab", function() { return Tab; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Toast", function() { return Toast; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tooltip", function() { return Tooltip; });
  !(function webpackMissingModule() { var e = new Error("Cannot find module '@popperjs/core'"); e.code = 'MODULE_NOT_FOUND'; throw e; }());
  var _KEY_TO_DIRECTION;
  
  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
  
  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
  
  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
  
  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
  
  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
  
  function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
  
  function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
  
  function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
  
  function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
  
  /*!
    * Bootstrap v5.1.3 (https://getbootstrap.com/)
    * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    */
  
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): 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 "".concat(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 getSelector = function getSelector(element) {
    var selector = element.getAttribute('data-bs-target');
  
    if (!selector || selector === '#') {
      var hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
      // `document.querySelector` will rightfully complain it is invalid.
      // See https://github.com/twbs/bootstrap/issues/32273
  
      if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {
        return null;
      } // Just in case some CMS puts out a full URL with the anchor appended
  
  
      if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
        hrefAttr = "#".concat(hrefAttr.split('#')[1]);
      }
  
      selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
    }
  
    return selector;
  };
  
  var getSelectorFromElement = function getSelectorFromElement(element) {
    var selector = getSelector(element);
  
    if (selector) {
      return document.querySelector(selector) ? selector : null;
    }
  
    return null;
  };
  
  var getElementFromSelector = function getElementFromSelector(element) {
    var selector = getSelector(element);
    return selector ? document.querySelector(selector) : null;
  };
  
  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) {
    if (!obj || _typeof(obj) !== 'object') {
      return false;
    }
  
    if (typeof obj.jquery !== 'undefined') {
      obj = obj[0];
    }
  
    return typeof obj.nodeType !== 'undefined';
  };
  
  var getElement = function getElement(obj) {
    if (isElement(obj)) {
      // it's a jQuery object or a node element
      return obj.jquery ? obj[0] : obj;
    }
  
    if (typeof obj === 'string' && obj.length > 0) {
      return document.querySelector(obj);
    }
  
    return null;
  };
  
  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 TypeError("".concat(componentName.toUpperCase(), ": Option \"").concat(property, "\" provided type \"").concat(valueType, "\" but expected type \"").concat(expectedTypes, "\"."));
      }
    });
  };
  
  var isVisible = function isVisible(element) {
    if (!isElement(element) || element.getClientRects().length === 0) {
      return false;
    }
  
    return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
  };
  
  var isDisabled = function isDisabled(element) {
    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
      return true;
    }
  
    if (element.classList.contains('disabled')) {
      return true;
    }
  
    if (typeof element.disabled !== 'undefined') {
      return element.disabled;
    }
  
    return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
  };
  
  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() {};
  /**
   * Trick to restart an element's animation
   *
   * @param {HTMLElement} element
   * @return void
   *
   * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
   */
  
  
  var reflow = function reflow(element) {
    // eslint-disable-next-line no-unused-expressions
    element.offsetHeight;
  };
  
  var getjQuery = function getjQuery() {
    var _window = window,
        jQuery = _window.jQuery;
  
    if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
      return jQuery;
    }
  
    return null;
  };
  
  var DOMContentLoadedCallbacks = [];
  
  var onDOMContentLoaded = function onDOMContentLoaded(callback) {
    if (document.readyState === 'loading') {
      // add listener on the first call when the document is in loading state
      if (!DOMContentLoadedCallbacks.length) {
        document.addEventListener('DOMContentLoaded', function () {
          DOMContentLoadedCallbacks.forEach(function (callback) {
            return callback();
          });
        });
      }
  
      DOMContentLoadedCallbacks.push(callback);
    } else {
      callback();
    }
  };
  
  var isRTL = function isRTL() {
    return document.documentElement.dir === 'rtl';
  };
  
  var defineJQueryPlugin = function defineJQueryPlugin(plugin) {
    onDOMContentLoaded(function () {
      var $ = getjQuery();
      /* istanbul ignore if */
  
      if ($) {
        var name = plugin.NAME;
        var JQUERY_NO_CONFLICT = $.fn[name];
        $.fn[name] = plugin.jQueryInterface;
        $.fn[name].Constructor = plugin;
  
        $.fn[name].noConflict = function () {
          $.fn[name] = JQUERY_NO_CONFLICT;
          return plugin.jQueryInterface;
        };
      }
    });
  };
  
  var execute = function execute(callback) {
    if (typeof callback === 'function') {
      callback();
    }
  };
  
  var executeAfterTransition = function executeAfterTransition(callback, transitionElement) {
    var waitForTransition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  
    if (!waitForTransition) {
      execute(callback);
      return;
    }
  
    var durationPadding = 5;
    var emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
    var called = false;
  
    var handler = function handler(_ref) {
      var target = _ref.target;
  
      if (target !== transitionElement) {
        return;
      }
  
      called = true;
      transitionElement.removeEventListener(TRANSITION_END, handler);
      execute(callback);
    };
  
    transitionElement.addEventListener(TRANSITION_END, handler);
    setTimeout(function () {
      if (!called) {
        triggerTransitionEnd(transitionElement);
      }
    }, emulatedDuration);
  };
  /**
   * Return the previous/next element of a list.
   *
   * @param {array} list    The list of elements
   * @param activeElement   The active element
   * @param shouldGetNext   Choose to get next or previous element
   * @param isCycleAllowed
   * @return {Element|elem} The proper element
   */
  
  
  var getNextActiveElement = function getNextActiveElement(list, activeElement, shouldGetNext, isCycleAllowed) {
    var 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
  
    if (index === -1) {
      return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0];
    }
  
    var listLength = list.length;
    index += shouldGetNext ? 1 : -1;
  
    if (isCycleAllowed) {
      index = (index + listLength) % listLength;
    }
  
    return list[Math.max(0, Math.min(index, listLength - 1))];
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): dom/event-handler.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  
  var namespaceRegex = /[^.]*(?=\..*)\.|.*/;
  var stripNameRegex = /\..*/;
  var stripUidRegex = /::\d+$/;
  var eventRegistry = {}; // Events storage
  
  var uidEvent = 1;
  var customEvents = {
    mouseenter: 'mouseover',
    mouseleave: 'mouseout'
  };
  var customEventsRegex = /^(mouseenter|mouseleave)/i;
  var 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']);
  /**
   * ------------------------------------------------------------------------
   * Private methods
   * ------------------------------------------------------------------------
   */
  
  function getUidEvent(element, uid) {
    return uid && "".concat(uid, "::").concat(uidEvent++) || element.uidEvent || uidEvent++;
  }
  
  function getEvent(element) {
    var uid = getUidEvent(element);
    element.uidEvent = uid;
    eventRegistry[uid] = eventRegistry[uid] || {};
    return eventRegistry[uid];
  }
  
  function bootstrapHandler(element, fn) {
    return function handler(event) {
      event.delegateTarget = element;
  
      if (handler.oneOff) {
        EventHandler.off(element, event.type, fn);
      }
  
      return fn.apply(element, [event]);
    };
  }
  
  function bootstrapDelegationHandler(element, selector, fn) {
    return function handler(event) {
      var domElements = element.querySelectorAll(selector);
  
      for (var target = event.target; target && target !== this; target = target.parentNode) {
        for (var i = domElements.length; i--;) {
          if (domElements[i] === target) {
            event.delegateTarget = target;
  
            if (handler.oneOff) {
              EventHandler.off(element, event.type, selector, fn);
            }
  
            return fn.apply(target, [event]);
          }
        }
      } // To please ESLint
  
  
      return null;
    };
  }
  
  function findHandler(events, handler) {
    var delegationSelector = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
    var uidEventList = Object.keys(events);
  
    for (var i = 0, len = uidEventList.length; i < len; i++) {
      var event = events[uidEventList[i]];
  
      if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
        return event;
      }
    }
  
    return null;
  }
  
  function normalizeParams(originalTypeEvent, handler, delegationFn) {
    var delegation = typeof handler === 'string';
    var originalHandler = delegation ? delegationFn : handler;
    var typeEvent = getTypeEvent(originalTypeEvent);
    var isNative = nativeEvents.has(typeEvent);
  
    if (!isNative) {
      typeEvent = originalTypeEvent;
    }
  
    return [delegation, originalHandler, typeEvent];
  }
  
  function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
    if (typeof originalTypeEvent !== 'string' || !element) {
      return;
    }
  
    if (!handler) {
      handler = delegationFn;
      delegationFn = null;
    } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
    // this prevents the handler from being dispatched the same way as mouseover or mouseout does
  
  
    if (customEventsRegex.test(originalTypeEvent)) {
      var wrapFn = function wrapFn(fn) {
        return function (event) {
          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
            return fn.call(this, event);
          }
        };
      };
  
      if (delegationFn) {
        delegationFn = wrapFn(delegationFn);
      } else {
        handler = wrapFn(handler);
      }
    }
  
    var _normalizeParams = normalizeParams(originalTypeEvent, handler, delegationFn),
        _normalizeParams2 = _slicedToArray(_normalizeParams, 3),
        delegation = _normalizeParams2[0],
        originalHandler = _normalizeParams2[1],
        typeEvent = _normalizeParams2[2];
  
    var events = getEvent(element);
    var handlers = events[typeEvent] || (events[typeEvent] = {});
    var previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
  
    if (previousFn) {
      previousFn.oneOff = previousFn.oneOff && oneOff;
      return;
    }
  
    var uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
    var fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
    fn.delegationSelector = delegation ? handler : null;
    fn.originalHandler = originalHandler;
    fn.oneOff = oneOff;
    fn.uidEvent = uid;
    handlers[uid] = fn;
    element.addEventListener(typeEvent, fn, delegation);
  }
  
  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
    var fn = findHandler(events[typeEvent], handler, delegationSelector);
  
    if (!fn) {
      return;
    }
  
    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
    delete events[typeEvent][fn.uidEvent];
  }
  
  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
    var storeElementEvent = events[typeEvent] || {};
    Object.keys(storeElementEvent).forEach(function (handlerKey) {
      if (handlerKey.includes(namespace)) {
        var event = storeElementEvent[handlerKey];
        removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
      }
    });
  }
  
  function getTypeEvent(event) {
    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
    event = event.replace(stripNameRegex, '');
    return customEvents[event] || event;
  }
  
  var EventHandler = {
    on: function on(element, event, handler, delegationFn) {
      addHandler(element, event, handler, delegationFn, false);
    },
    one: function one(element, event, handler, delegationFn) {
      addHandler(element, event, handler, delegationFn, true);
    },
    off: function off(element, originalTypeEvent, handler, delegationFn) {
      if (typeof originalTypeEvent !== 'string' || !element) {
        return;
      }
  
      var _normalizeParams3 = normalizeParams(originalTypeEvent, handler, delegationFn),
          _normalizeParams4 = _slicedToArray(_normalizeParams3, 3),
          delegation = _normalizeParams4[0],
          originalHandler = _normalizeParams4[1],
          typeEvent = _normalizeParams4[2];
  
      var inNamespace = typeEvent !== originalTypeEvent;
      var events = getEvent(element);
      var isNamespace = originalTypeEvent.startsWith('.');
  
      if (typeof originalHandler !== 'undefined') {
        // Simplest case: handler is passed, remove that listener ONLY.
        if (!events || !events[typeEvent]) {
          return;
        }
  
        removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
        return;
      }
  
      if (isNamespace) {
        Object.keys(events).forEach(function (elementEvent) {
          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
        });
      }
  
      var storeElementEvent = events[typeEvent] || {};
      Object.keys(storeElementEvent).forEach(function (keyHandlers) {
        var handlerKey = keyHandlers.replace(stripUidRegex, '');
  
        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
          var event = storeElementEvent[keyHandlers];
          removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
        }
      });
    },
    trigger: function trigger(element, event, args) {
      if (typeof event !== 'string' || !element) {
        return null;
      }
  
      var $ = getjQuery();
      var typeEvent = getTypeEvent(event);
      var inNamespace = event !== typeEvent;
      var isNative = nativeEvents.has(typeEvent);
      var jQueryEvent;
      var bubbles = true;
      var nativeDispatch = true;
      var defaultPrevented = false;
      var evt = null;
  
      if (inNamespace && $) {
        jQueryEvent = $.Event(event, args);
        $(element).trigger(jQueryEvent);
        bubbles = !jQueryEvent.isPropagationStopped();
        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
        defaultPrevented = jQueryEvent.isDefaultPrevented();
      }
  
      if (isNative) {
        evt = document.createEvent('HTMLEvents');
        evt.initEvent(typeEvent, bubbles, true);
      } else {
        evt = new CustomEvent(event, {
          bubbles: bubbles,
          cancelable: true
        });
      } // merge custom information in our event
  
  
      if (typeof args !== 'undefined') {
        Object.keys(args).forEach(function (key) {
          Object.defineProperty(evt, key, {
            get: function get() {
              return args[key];
            }
          });
        });
      }
  
      if (defaultPrevented) {
        evt.preventDefault();
      }
  
      if (nativeDispatch) {
        element.dispatchEvent(evt);
      }
  
      if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
        jQueryEvent.preventDefault();
      }
  
      return evt;
    }
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): dom/data.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var elementMap = new Map();
  var Data = {
    set: function set(element, key, instance) {
      if (!elementMap.has(element)) {
        elementMap.set(element, new Map());
      }
  
      var instanceMap = elementMap.get(element); // make it clear we only want one instance per element
      // can be removed later when multiple key/instances are fine to be used
  
      if (!instanceMap.has(key) && instanceMap.size !== 0) {
        // eslint-disable-next-line no-console
        console.error("Bootstrap doesn't allow more than one instance per element. Bound instance: ".concat(Array.from(instanceMap.keys())[0], "."));
        return;
      }
  
      instanceMap.set(key, instance);
    },
    get: function get(element, key) {
      if (elementMap.has(element)) {
        return elementMap.get(element).get(key) || null;
      }
  
      return null;
    },
    remove: function remove(element, key) {
      if (!elementMap.has(element)) {
        return;
      }
  
      var instanceMap = elementMap.get(element);
      instanceMap.delete(key); // free up element references if there are no instances left for an element
  
      if (instanceMap.size === 0) {
        elementMap.delete(element);
      }
    }
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): base-component.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var VERSION = '5.1.3';
  
  var BaseComponent = /*#__PURE__*/function () {
    function BaseComponent(element) {
      _classCallCheck(this, BaseComponent);
  
      element = getElement(element);
  
      if (!element) {
        return;
      }
  
      this._element = element;
      Data.set(this._element, this.constructor.DATA_KEY, this);
    }
  
    _createClass(BaseComponent, [{
      key: "dispose",
      value: function dispose() {
        var _this = this;
  
        Data.remove(this._element, this.constructor.DATA_KEY);
        EventHandler.off(this._element, this.constructor.EVENT_KEY);
        Object.getOwnPropertyNames(this).forEach(function (propertyName) {
          _this[propertyName] = null;
        });
      }
    }, {
      key: "_queueCallback",
      value: function _queueCallback(callback, element) {
        var isAnimated = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
        executeAfterTransition(callback, element, isAnimated);
      }
      /** Static */
  
    }], [{
      key: "getInstance",
      value: function getInstance(element) {
        return Data.get(getElement(element), this.DATA_KEY);
      }
    }, {
      key: "getOrCreateInstance",
      value: function getOrCreateInstance(element) {
        var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        return this.getInstance(element) || new this(element, _typeof(config) === 'object' ? config : null);
      }
    }, {
      key: "VERSION",
      get: function get() {
        return VERSION;
      }
    }, {
      key: "NAME",
      get: function get() {
        throw new Error('You have to implement the static method "NAME", for each component!');
      }
    }, {
      key: "DATA_KEY",
      get: function get() {
        return "bs.".concat(this.NAME);
      }
    }, {
      key: "EVENT_KEY",
      get: function get() {
        return ".".concat(this.DATA_KEY);
      }
    }]);
  
    return BaseComponent;
  }();
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): util/component-functions.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  
  var enableDismissTrigger = function enableDismissTrigger(component) {
    var method = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'hide';
    var clickEvent = "click.dismiss".concat(component.EVENT_KEY);
    var name = component.NAME;
    EventHandler.on(document, clickEvent, "[data-bs-dismiss=\"".concat(name, "\"]"), function (event) {
      if (['A', 'AREA'].includes(this.tagName)) {
        event.preventDefault();
      }
  
      if (isDisabled(this)) {
        return;
      }
  
      var target = getElementFromSelector(this) || this.closest(".".concat(name));
      var instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
  
      instance[method]();
    });
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): alert.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  
  var NAME$d = 'alert';
  var DATA_KEY$c = 'bs.alert';
  var EVENT_KEY$c = ".".concat(DATA_KEY$c);
  var EVENT_CLOSE = "close".concat(EVENT_KEY$c);
  var EVENT_CLOSED = "closed".concat(EVENT_KEY$c);
  var CLASS_NAME_FADE$5 = 'fade';
  var CLASS_NAME_SHOW$8 = 'show';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Alert = /*#__PURE__*/function (_BaseComponent) {
    _inherits(Alert, _BaseComponent);
  
    var _super = _createSuper(Alert);
  
    function Alert() {
      _classCallCheck(this, Alert);
  
      return _super.apply(this, arguments);
    }
  
    _createClass(Alert, [{
      key: "close",
      value: // Public
      function close() {
        var _this2 = this;
  
        var closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
  
        if (closeEvent.defaultPrevented) {
          return;
        }
  
        this._element.classList.remove(CLASS_NAME_SHOW$8);
  
        var isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
  
        this._queueCallback(function () {
          return _this2._destroyElement();
        }, this._element, isAnimated);
      } // Private
  
    }, {
      key: "_destroyElement",
      value: function _destroyElement() {
        this._element.remove();
  
        EventHandler.trigger(this._element, EVENT_CLOSED);
        this.dispose();
      } // Static
  
    }], [{
      key: "NAME",
      get: // Getters
      function get() {
        return NAME$d;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Alert.getOrCreateInstance(this);
  
          if (typeof config !== 'string') {
            return;
          }
  
          if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
            throw new TypeError("No method named \"".concat(config, "\""));
          }
  
          data[config](this);
        });
      }
    }]);
  
    return Alert;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  enableDismissTrigger(Alert, 'close');
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Alert to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Alert);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): button.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$c = 'button';
  var DATA_KEY$b = 'bs.button';
  var EVENT_KEY$b = ".".concat(DATA_KEY$b);
  var DATA_API_KEY$7 = '.data-api';
  var CLASS_NAME_ACTIVE$3 = 'active';
  var SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
  var EVENT_CLICK_DATA_API$6 = "click".concat(EVENT_KEY$b).concat(DATA_API_KEY$7);
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Button = /*#__PURE__*/function (_BaseComponent2) {
    _inherits(Button, _BaseComponent2);
  
    var _super2 = _createSuper(Button);
  
    function Button() {
      _classCallCheck(this, Button);
  
      return _super2.apply(this, arguments);
    }
  
    _createClass(Button, [{
      key: "toggle",
      value: // Public
      function toggle() {
        // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
        this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
      } // Static
  
    }], [{
      key: "NAME",
      get: // Getters
      function get() {
        return NAME$c;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Button.getOrCreateInstance(this);
  
          if (config === 'toggle') {
            data[config]();
          }
        });
      }
    }]);
  
    return Button;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, function (event) {
    event.preventDefault();
    var button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
    var data = Button.getOrCreateInstance(button);
    data.toggle();
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Button to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Button);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): dom/manipulator.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  function normalizeData(val) {
    if (val === 'true') {
      return true;
    }
  
    if (val === 'false') {
      return false;
    }
  
    if (val === Number(val).toString()) {
      return Number(val);
    }
  
    if (val === '' || val === 'null') {
      return null;
    }
  
    return val;
  }
  
  function normalizeDataKey(key) {
    return key.replace(/[A-Z]/g, function (chr) {
      return "-".concat(chr.toLowerCase());
    });
  }
  
  var Manipulator = {
    setDataAttribute: function setDataAttribute(element, key, value) {
      element.setAttribute("data-bs-".concat(normalizeDataKey(key)), value);
    },
    removeDataAttribute: function removeDataAttribute(element, key) {
      element.removeAttribute("data-bs-".concat(normalizeDataKey(key)));
    },
    getDataAttributes: function getDataAttributes(element) {
      if (!element) {
        return {};
      }
  
      var attributes = {};
      Object.keys(element.dataset).filter(function (key) {
        return key.startsWith('bs');
      }).forEach(function (key) {
        var pureKey = key.replace(/^bs/, '');
        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
        attributes[pureKey] = normalizeData(element.dataset[key]);
      });
      return attributes;
    },
    getDataAttribute: function getDataAttribute(element, key) {
      return normalizeData(element.getAttribute("data-bs-".concat(normalizeDataKey(key))));
    },
    offset: function offset(element) {
      var rect = element.getBoundingClientRect();
      return {
        top: rect.top + window.pageYOffset,
        left: rect.left + window.pageXOffset
      };
    },
    position: function position(element) {
      return {
        top: element.offsetTop,
        left: element.offsetLeft
      };
    }
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): dom/selector-engine.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  var NODE_TEXT = 3;
  var SelectorEngine = {
    find: function find(selector) {
      var _ref2;
  
      var element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document.documentElement;
      return (_ref2 = []).concat.apply(_ref2, _toConsumableArray(Element.prototype.querySelectorAll.call(element, selector)));
    },
    findOne: function findOne(selector) {
      var element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document.documentElement;
      return Element.prototype.querySelector.call(element, selector);
    },
    children: function children(element, selector) {
      var _ref3;
  
      return (_ref3 = []).concat.apply(_ref3, _toConsumableArray(element.children)).filter(function (child) {
        return child.matches(selector);
      });
    },
    parents: function parents(element, selector) {
      var parents = [];
      var ancestor = element.parentNode;
  
      while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
        if (ancestor.matches(selector)) {
          parents.push(ancestor);
        }
  
        ancestor = ancestor.parentNode;
      }
  
      return parents;
    },
    prev: function prev(element, selector) {
      var previous = element.previousElementSibling;
  
      while (previous) {
        if (previous.matches(selector)) {
          return [previous];
        }
  
        previous = previous.previousElementSibling;
      }
  
      return [];
    },
    next: function next(element, selector) {
      var next = element.nextElementSibling;
  
      while (next) {
        if (next.matches(selector)) {
          return [next];
        }
  
        next = next.nextElementSibling;
      }
  
      return [];
    },
    focusableChildren: function focusableChildren(element) {
      var focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(function (selector) {
        return "".concat(selector, ":not([tabindex^=\"-\"])");
      }).join(', ');
      return this.find(focusables, element).filter(function (el) {
        return !isDisabled(el) && isVisible(el);
      });
    }
  };
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): carousel.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$b = 'carousel';
  var DATA_KEY$a = 'bs.carousel';
  var EVENT_KEY$a = ".".concat(DATA_KEY$a);
  var DATA_API_KEY$6 = '.data-api';
  var ARROW_LEFT_KEY = 'ArrowLeft';
  var ARROW_RIGHT_KEY = 'ArrowRight';
  var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
  
  var SWIPE_THRESHOLD = 40;
  var Default$a = {
    interval: 5000,
    keyboard: true,
    slide: false,
    pause: 'hover',
    wrap: true,
    touch: true
  };
  var DefaultType$a = {
    interval: '(number|boolean)',
    keyboard: 'boolean',
    slide: '(boolean|string)',
    pause: '(string|boolean)',
    wrap: 'boolean',
    touch: 'boolean'
  };
  var ORDER_NEXT = 'next';
  var ORDER_PREV = 'prev';
  var DIRECTION_LEFT = 'left';
  var DIRECTION_RIGHT = 'right';
  var KEY_TO_DIRECTION = (_KEY_TO_DIRECTION = {}, _defineProperty(_KEY_TO_DIRECTION, ARROW_LEFT_KEY, DIRECTION_RIGHT), _defineProperty(_KEY_TO_DIRECTION, ARROW_RIGHT_KEY, DIRECTION_LEFT), _KEY_TO_DIRECTION);
  var EVENT_SLIDE = "slide".concat(EVENT_KEY$a);
  var EVENT_SLID = "slid".concat(EVENT_KEY$a);
  var EVENT_KEYDOWN = "keydown".concat(EVENT_KEY$a);
  var EVENT_MOUSEENTER = "mouseenter".concat(EVENT_KEY$a);
  var EVENT_MOUSELEAVE = "mouseleave".concat(EVENT_KEY$a);
  var EVENT_TOUCHSTART = "touchstart".concat(EVENT_KEY$a);
  var EVENT_TOUCHMOVE = "touchmove".concat(EVENT_KEY$a);
  var EVENT_TOUCHEND = "touchend".concat(EVENT_KEY$a);
  var EVENT_POINTERDOWN = "pointerdown".concat(EVENT_KEY$a);
  var EVENT_POINTERUP = "pointerup".concat(EVENT_KEY$a);
  var EVENT_DRAG_START = "dragstart".concat(EVENT_KEY$a);
  var EVENT_LOAD_DATA_API$2 = "load".concat(EVENT_KEY$a).concat(DATA_API_KEY$6);
  var EVENT_CLICK_DATA_API$5 = "click".concat(EVENT_KEY$a).concat(DATA_API_KEY$6);
  var CLASS_NAME_CAROUSEL = 'carousel';
  var CLASS_NAME_ACTIVE$2 = 'active';
  var CLASS_NAME_SLIDE = 'slide';
  var CLASS_NAME_END = 'carousel-item-end';
  var CLASS_NAME_START = 'carousel-item-start';
  var CLASS_NAME_NEXT = 'carousel-item-next';
  var CLASS_NAME_PREV = 'carousel-item-prev';
  var CLASS_NAME_POINTER_EVENT = 'pointer-event';
  var SELECTOR_ACTIVE$1 = '.active';
  var SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
  var SELECTOR_ITEM = '.carousel-item';
  var SELECTOR_ITEM_IMG = '.carousel-item img';
  var SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev';
  var SELECTOR_INDICATORS = '.carousel-indicators';
  var SELECTOR_INDICATOR = '[data-bs-target]';
  var SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
  var SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
  var POINTER_TYPE_TOUCH = 'touch';
  var POINTER_TYPE_PEN = 'pen';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Carousel = /*#__PURE__*/function (_BaseComponent3) {
    _inherits(Carousel, _BaseComponent3);
  
    var _super3 = _createSuper(Carousel);
  
    function Carousel(element, config) {
      var _this3;
  
      _classCallCheck(this, Carousel);
  
      _this3 = _super3.call(this, element);
      _this3._items = null;
      _this3._interval = null;
      _this3._activeElement = null;
      _this3._isPaused = false;
      _this3._isSliding = false;
      _this3.touchTimeout = null;
      _this3.touchStartX = 0;
      _this3.touchDeltaX = 0;
      _this3._config = _this3._getConfig(config);
      _this3._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, _this3._element);
      _this3._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
      _this3._pointerEvent = Boolean(window.PointerEvent);
  
      _this3._addEventListeners();
  
      return _this3;
    } // Getters
  
  
    _createClass(Carousel, [{
      key: "next",
      value: // Public
      function next() {
        this._slide(ORDER_NEXT);
      }
    }, {
      key: "nextWhenVisible",
      value: function nextWhenVisible() {
        // Don't call next when the page isn't visible
        // or the carousel or its parent isn't visible
        if (!document.hidden && isVisible(this._element)) {
          this.next();
        }
      }
    }, {
      key: "prev",
      value: function prev() {
        this._slide(ORDER_PREV);
      }
    }, {
      key: "pause",
      value: function pause(event) {
        if (!event) {
          this._isPaused = true;
        }
  
        if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
          triggerTransitionEnd(this._element);
          this.cycle(true);
        }
  
        clearInterval(this._interval);
        this._interval = null;
      }
    }, {
      key: "cycle",
      value: function cycle(event) {
        if (!event) {
          this._isPaused = false;
        }
  
        if (this._interval) {
          clearInterval(this._interval);
          this._interval = null;
        }
  
        if (this._config && this._config.interval && !this._isPaused) {
          this._updateInterval();
  
          this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
        }
      }
    }, {
      key: "to",
      value: function to(index) {
        var _this4 = this;
  
        this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
  
        var activeIndex = this._getItemIndex(this._activeElement);
  
        if (index > this._items.length - 1 || index < 0) {
          return;
        }
  
        if (this._isSliding) {
          EventHandler.one(this._element, EVENT_SLID, function () {
            return _this4.to(index);
          });
          return;
        }
  
        if (activeIndex === index) {
          this.pause();
          this.cycle();
          return;
        }
  
        var order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
  
        this._slide(order, this._items[index]);
      } // Private
  
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default$a), Manipulator.getDataAttributes(this._element)), _typeof(config) === 'object' ? config : {});
        typeCheckConfig(NAME$b, config, DefaultType$a);
        return config;
      }
    }, {
      key: "_handleSwipe",
      value: function _handleSwipe() {
        var absDeltax = Math.abs(this.touchDeltaX);
  
        if (absDeltax <= SWIPE_THRESHOLD) {
          return;
        }
  
        var direction = absDeltax / this.touchDeltaX;
        this.touchDeltaX = 0;
  
        if (!direction) {
          return;
        }
  
        this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
      }
    }, {
      key: "_addEventListeners",
      value: function _addEventListeners() {
        var _this5 = this;
  
        if (this._config.keyboard) {
          EventHandler.on(this._element, EVENT_KEYDOWN, function (event) {
            return _this5._keydown(event);
          });
        }
  
        if (this._config.pause === 'hover') {
          EventHandler.on(this._element, EVENT_MOUSEENTER, function (event) {
            return _this5.pause(event);
          });
          EventHandler.on(this._element, EVENT_MOUSELEAVE, function (event) {
            return _this5.cycle(event);
          });
        }
  
        if (this._config.touch && this._touchSupported) {
          this._addTouchEventListeners();
        }
      }
    }, {
      key: "_addTouchEventListeners",
      value: function _addTouchEventListeners() {
        var _this6 = this;
  
        var hasPointerPenTouch = function hasPointerPenTouch(event) {
          return _this6._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
        };
  
        var start = function start(event) {
          if (hasPointerPenTouch(event)) {
            _this6.touchStartX = event.clientX;
          } else if (!_this6._pointerEvent) {
            _this6.touchStartX = event.touches[0].clientX;
          }
        };
  
        var move = function move(event) {
          // ensure swiping with one touch and not pinching
          _this6.touchDeltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - _this6.touchStartX;
        };
  
        var end = function end(event) {
          if (hasPointerPenTouch(event)) {
            _this6.touchDeltaX = event.clientX - _this6.touchStartX;
          }
  
          _this6._handleSwipe();
  
          if (_this6._config.pause === 'hover') {
            // If it's a touch-enabled device, mouseenter/leave are fired as
            // part of the mouse compatibility events on first tap - the carousel
            // would stop cycling until user tapped out of it;
            // here, we listen for touchend, explicitly pause the carousel
            // (as if it's the second time we tap on it, mouseenter compat event
            // is NOT fired) and after a timeout (to allow for mouse compatibility
            // events to fire) we explicitly restart cycling
            _this6.pause();
  
            if (_this6.touchTimeout) {
              clearTimeout(_this6.touchTimeout);
            }
  
            _this6.touchTimeout = setTimeout(function (event) {
              return _this6.cycle(event);
            }, TOUCHEVENT_COMPAT_WAIT + _this6._config.interval);
          }
        };
  
        SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(function (itemImg) {
          EventHandler.on(itemImg, EVENT_DRAG_START, function (event) {
            return event.preventDefault();
          });
        });
  
        if (this._pointerEvent) {
          EventHandler.on(this._element, EVENT_POINTERDOWN, function (event) {
            return start(event);
          });
          EventHandler.on(this._element, EVENT_POINTERUP, function (event) {
            return end(event);
          });
  
          this._element.classList.add(CLASS_NAME_POINTER_EVENT);
        } else {
          EventHandler.on(this._element, EVENT_TOUCHSTART, function (event) {
            return start(event);
          });
          EventHandler.on(this._element, EVENT_TOUCHMOVE, function (event) {
            return move(event);
          });
          EventHandler.on(this._element, EVENT_TOUCHEND, function (event) {
            return end(event);
          });
        }
      }
    }, {
      key: "_keydown",
      value: function _keydown(event) {
        if (/input|textarea/i.test(event.target.tagName)) {
          return;
        }
  
        var direction = KEY_TO_DIRECTION[event.key];
  
        if (direction) {
          event.preventDefault();
  
          this._slide(direction);
        }
      }
    }, {
      key: "_getItemIndex",
      value: function _getItemIndex(element) {
        this._items = element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
        return this._items.indexOf(element);
      }
    }, {
      key: "_getItemByOrder",
      value: function _getItemByOrder(order, activeElement) {
        var isNext = order === ORDER_NEXT;
        return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap);
      }
    }, {
      key: "_triggerSlideEvent",
      value: function _triggerSlideEvent(relatedTarget, eventDirectionName) {
        var targetIndex = this._getItemIndex(relatedTarget);
  
        var fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element));
  
        return EventHandler.trigger(this._element, EVENT_SLIDE, {
          relatedTarget: relatedTarget,
          direction: eventDirectionName,
          from: fromIndex,
          to: targetIndex
        });
      }
    }, {
      key: "_setActiveIndicatorElement",
      value: function _setActiveIndicatorElement(element) {
        if (this._indicatorsElement) {
          var activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE$1, this._indicatorsElement);
          activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
          activeIndicator.removeAttribute('aria-current');
          var indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
  
          for (var i = 0; i < indicators.length; i++) {
            if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
              indicators[i].classList.add(CLASS_NAME_ACTIVE$2);
              indicators[i].setAttribute('aria-current', 'true');
              break;
            }
          }
        }
      }
    }, {
      key: "_updateInterval",
      value: function _updateInterval() {
        var element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
  
        if (!element) {
          return;
        }
  
        var elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
  
        if (elementInterval) {
          this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
          this._config.interval = elementInterval;
        } else {
          this._config.interval = this._config.defaultInterval || this._config.interval;
        }
      }
    }, {
      key: "_slide",
      value: function _slide(directionOrOrder, element) {
        var _this7 = this;
  
        var order = this._directionToOrder(directionOrOrder);
  
        var activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
  
        var activeElementIndex = this._getItemIndex(activeElement);
  
        var nextElement = element || this._getItemByOrder(order, activeElement);
  
        var nextElementIndex = this._getItemIndex(nextElement);
  
        var isCycling = Boolean(this._interval);
        var isNext = order === ORDER_NEXT;
        var directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
        var orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
  
        var eventDirectionName = this._orderToDirection(order);
  
        if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$2)) {
          this._isSliding = false;
          return;
        }
  
        if (this._isSliding) {
          return;
        }
  
        var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
  
        if (slideEvent.defaultPrevented) {
          return;
        }
  
        if (!activeElement || !nextElement) {
          // Some weirdness is happening, so we bail
          return;
        }
  
        this._isSliding = true;
  
        if (isCycling) {
          this.pause();
        }
  
        this._setActiveIndicatorElement(nextElement);
  
        this._activeElement = nextElement;
  
        var triggerSlidEvent = function triggerSlidEvent() {
          EventHandler.trigger(_this7._element, EVENT_SLID, {
            relatedTarget: nextElement,
            direction: eventDirectionName,
            from: activeElementIndex,
            to: nextElementIndex
          });
        };
  
        if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
          nextElement.classList.add(orderClassName);
          reflow(nextElement);
          activeElement.classList.add(directionalClassName);
          nextElement.classList.add(directionalClassName);
  
          var completeCallBack = function completeCallBack() {
            nextElement.classList.remove(directionalClassName, orderClassName);
            nextElement.classList.add(CLASS_NAME_ACTIVE$2);
            activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
            _this7._isSliding = false;
            setTimeout(triggerSlidEvent, 0);
          };
  
          this._queueCallback(completeCallBack, activeElement, true);
        } else {
          activeElement.classList.remove(CLASS_NAME_ACTIVE$2);
          nextElement.classList.add(CLASS_NAME_ACTIVE$2);
          this._isSliding = false;
          triggerSlidEvent();
        }
  
        if (isCycling) {
          this.cycle();
        }
      }
    }, {
      key: "_directionToOrder",
      value: function _directionToOrder(direction) {
        if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
          return direction;
        }
  
        if (isRTL()) {
          return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
        }
  
        return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
      }
    }, {
      key: "_orderToDirection",
      value: function _orderToDirection(order) {
        if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
          return order;
        }
  
        if (isRTL()) {
          return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
        }
  
        return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$a;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$b;
      }
    }, {
      key: "carouselInterface",
      value: function carouselInterface(element, config) {
        var data = Carousel.getOrCreateInstance(element, config);
        var _config = data._config;
  
        if (_typeof(config) === 'object') {
          _config = _objectSpread(_objectSpread({}, _config), config);
        }
  
        var action = typeof config === 'string' ? config : _config.slide;
  
        if (typeof config === 'number') {
          data.to(config);
        } else if (typeof action === 'string') {
          if (typeof data[action] === 'undefined') {
            throw new TypeError("No method named \"".concat(action, "\""));
          }
  
          data[action]();
        } else if (_config.interval && _config.ride) {
          data.pause();
          data.cycle();
        }
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          Carousel.carouselInterface(this, config);
        });
      }
    }, {
      key: "dataApiClickHandler",
      value: function dataApiClickHandler(event) {
        var target = getElementFromSelector(this);
  
        if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
          return;
        }
  
        var config = _objectSpread(_objectSpread({}, Manipulator.getDataAttributes(target)), Manipulator.getDataAttributes(this));
  
        var slideIndex = this.getAttribute('data-bs-slide-to');
  
        if (slideIndex) {
          config.interval = false;
        }
  
        Carousel.carouselInterface(target, config);
  
        if (slideIndex) {
          Carousel.getInstance(target).to(slideIndex);
        }
  
        event.preventDefault();
      }
    }]);
  
    return Carousel;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
  EventHandler.on(window, EVENT_LOAD_DATA_API$2, function () {
    var carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
  
    for (var i = 0, len = carousels.length; i < len; i++) {
      Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]));
    }
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Carousel to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Carousel);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): collapse.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$a = 'collapse';
  var DATA_KEY$9 = 'bs.collapse';
  var EVENT_KEY$9 = ".".concat(DATA_KEY$9);
  var DATA_API_KEY$5 = '.data-api';
  var Default$9 = {
    toggle: true,
    parent: null
  };
  var DefaultType$9 = {
    toggle: 'boolean',
    parent: '(null|element)'
  };
  var EVENT_SHOW$5 = "show".concat(EVENT_KEY$9);
  var EVENT_SHOWN$5 = "shown".concat(EVENT_KEY$9);
  var EVENT_HIDE$5 = "hide".concat(EVENT_KEY$9);
  var EVENT_HIDDEN$5 = "hidden".concat(EVENT_KEY$9);
  var EVENT_CLICK_DATA_API$4 = "click".concat(EVENT_KEY$9).concat(DATA_API_KEY$5);
  var CLASS_NAME_SHOW$7 = 'show';
  var CLASS_NAME_COLLAPSE = 'collapse';
  var CLASS_NAME_COLLAPSING = 'collapsing';
  var CLASS_NAME_COLLAPSED = 'collapsed';
  var CLASS_NAME_DEEPER_CHILDREN = ":scope .".concat(CLASS_NAME_COLLAPSE, " .").concat(CLASS_NAME_COLLAPSE);
  var CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
  var WIDTH = 'width';
  var HEIGHT = 'height';
  var SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
  var SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Collapse = /*#__PURE__*/function (_BaseComponent4) {
    _inherits(Collapse, _BaseComponent4);
  
    var _super4 = _createSuper(Collapse);
  
    function Collapse(element, config) {
      var _this8;
  
      _classCallCheck(this, Collapse);
  
      _this8 = _super4.call(this, element);
      _this8._isTransitioning = false;
      _this8._config = _this8._getConfig(config);
      _this8._triggerArray = [];
      var toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
  
      for (var i = 0, len = toggleList.length; i < len; i++) {
        var elem = toggleList[i];
        var selector = getSelectorFromElement(elem);
        var filterElement = SelectorEngine.find(selector).filter(function (foundElem) {
          return foundElem === _this8._element;
        });
  
        if (selector !== null && filterElement.length) {
          _this8._selector = selector;
  
          _this8._triggerArray.push(elem);
        }
      }
  
      _this8._initializeChildren();
  
      if (!_this8._config.parent) {
        _this8._addAriaAndCollapsedClass(_this8._triggerArray, _this8._isShown());
      }
  
      if (_this8._config.toggle) {
        _this8.toggle();
      }
  
      return _this8;
    } // Getters
  
  
    _createClass(Collapse, [{
      key: "toggle",
      value: // Public
      function toggle() {
        if (this._isShown()) {
          this.hide();
        } else {
          this.show();
        }
      }
    }, {
      key: "show",
      value: function show() {
        var _this9 = this;
  
        if (this._isTransitioning || this._isShown()) {
          return;
        }
  
        var actives = [];
        var activesData;
  
        if (this._config.parent) {
          var children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
          actives = SelectorEngine.find(SELECTOR_ACTIVES, this._config.parent).filter(function (elem) {
            return !children.includes(elem);
          }); // remove children if greater depth
        }
  
        var container = SelectorEngine.findOne(this._selector);
  
        if (actives.length) {
          var tempActiveData = actives.find(function (elem) {
            return container !== elem;
          });
          activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
  
          if (activesData && activesData._isTransitioning) {
            return;
          }
        }
  
        var startEvent = EventHandler.trigger(this._element, EVENT_SHOW$5);
  
        if (startEvent.defaultPrevented) {
          return;
        }
  
        actives.forEach(function (elemActive) {
          if (container !== elemActive) {
            Collapse.getOrCreateInstance(elemActive, {
              toggle: false
            }).hide();
          }
  
          if (!activesData) {
            Data.set(elemActive, DATA_KEY$9, null);
          }
        });
  
        var dimension = this._getDimension();
  
        this._element.classList.remove(CLASS_NAME_COLLAPSE);
  
        this._element.classList.add(CLASS_NAME_COLLAPSING);
  
        this._element.style[dimension] = 0;
  
        this._addAriaAndCollapsedClass(this._triggerArray, true);
  
        this._isTransitioning = true;
  
        var complete = function complete() {
          _this9._isTransitioning = false;
  
          _this9._element.classList.remove(CLASS_NAME_COLLAPSING);
  
          _this9._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
  
          _this9._element.style[dimension] = '';
          EventHandler.trigger(_this9._element, EVENT_SHOWN$5);
        };
  
        var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
        var scrollSize = "scroll".concat(capitalizedDimension);
  
        this._queueCallback(complete, this._element, true);
  
        this._element.style[dimension] = "".concat(this._element[scrollSize], "px");
      }
    }, {
      key: "hide",
      value: function hide() {
        var _this10 = this;
  
        if (this._isTransitioning || !this._isShown()) {
          return;
        }
  
        var startEvent = EventHandler.trigger(this._element, EVENT_HIDE$5);
  
        if (startEvent.defaultPrevented) {
          return;
        }
  
        var dimension = this._getDimension();
  
        this._element.style[dimension] = "".concat(this._element.getBoundingClientRect()[dimension], "px");
        reflow(this._element);
  
        this._element.classList.add(CLASS_NAME_COLLAPSING);
  
        this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
  
        var triggerArrayLength = this._triggerArray.length;
  
        for (var i = 0; i < triggerArrayLength; i++) {
          var trigger = this._triggerArray[i];
          var elem = getElementFromSelector(trigger);
  
          if (elem && !this._isShown(elem)) {
            this._addAriaAndCollapsedClass([trigger], false);
          }
        }
  
        this._isTransitioning = true;
  
        var complete = function complete() {
          _this10._isTransitioning = false;
  
          _this10._element.classList.remove(CLASS_NAME_COLLAPSING);
  
          _this10._element.classList.add(CLASS_NAME_COLLAPSE);
  
          EventHandler.trigger(_this10._element, EVENT_HIDDEN$5);
        };
  
        this._element.style[dimension] = '';
  
        this._queueCallback(complete, this._element, true);
      }
    }, {
      key: "_isShown",
      value: function _isShown() {
        var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._element;
        return element.classList.contains(CLASS_NAME_SHOW$7);
      } // Private
  
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default$9), Manipulator.getDataAttributes(this._element)), config);
        config.toggle = Boolean(config.toggle); // Coerce string values
  
        config.parent = getElement(config.parent);
        typeCheckConfig(NAME$a, config, DefaultType$9);
        return config;
      }
    }, {
      key: "_getDimension",
      value: function _getDimension() {
        return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
      }
    }, {
      key: "_initializeChildren",
      value: function _initializeChildren() {
        var _this11 = this;
  
        if (!this._config.parent) {
          return;
        }
  
        var children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
        SelectorEngine.find(SELECTOR_DATA_TOGGLE$4, this._config.parent).filter(function (elem) {
          return !children.includes(elem);
        }).forEach(function (element) {
          var selected = getElementFromSelector(element);
  
          if (selected) {
            _this11._addAriaAndCollapsedClass([element], _this11._isShown(selected));
          }
        });
      }
    }, {
      key: "_addAriaAndCollapsedClass",
      value: function _addAriaAndCollapsedClass(triggerArray, isOpen) {
        if (!triggerArray.length) {
          return;
        }
  
        triggerArray.forEach(function (elem) {
          if (isOpen) {
            elem.classList.remove(CLASS_NAME_COLLAPSED);
          } else {
            elem.classList.add(CLASS_NAME_COLLAPSED);
          }
  
          elem.setAttribute('aria-expanded', isOpen);
        });
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$9;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$a;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var _config = {};
  
          if (typeof config === 'string' && /show|hide/.test(config)) {
            _config.toggle = false;
          }
  
          var data = Collapse.getOrCreateInstance(this, _config);
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError("No method named \"".concat(config, "\""));
            }
  
            data[config]();
          }
        });
      }
    }]);
  
    return Collapse;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
      event.preventDefault();
    }
  
    var selector = getSelectorFromElement(this);
    var selectorElements = SelectorEngine.find(selector);
    selectorElements.forEach(function (element) {
      Collapse.getOrCreateInstance(element, {
        toggle: false
      }).toggle();
    });
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Collapse to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Collapse);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): dropdown.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$9 = 'dropdown';
  var DATA_KEY$8 = 'bs.dropdown';
  var EVENT_KEY$8 = ".".concat(DATA_KEY$8);
  var DATA_API_KEY$4 = '.data-api';
  var ESCAPE_KEY$2 = 'Escape';
  var SPACE_KEY = 'Space';
  var TAB_KEY$1 = 'Tab';
  var ARROW_UP_KEY = 'ArrowUp';
  var ARROW_DOWN_KEY = 'ArrowDown';
  var RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
  
  var REGEXP_KEYDOWN = new RegExp("".concat(ARROW_UP_KEY, "|").concat(ARROW_DOWN_KEY, "|").concat(ESCAPE_KEY$2));
  var EVENT_HIDE$4 = "hide".concat(EVENT_KEY$8);
  var EVENT_HIDDEN$4 = "hidden".concat(EVENT_KEY$8);
  var EVENT_SHOW$4 = "show".concat(EVENT_KEY$8);
  var EVENT_SHOWN$4 = "shown".concat(EVENT_KEY$8);
  var EVENT_CLICK_DATA_API$3 = "click".concat(EVENT_KEY$8).concat(DATA_API_KEY$4);
  var EVENT_KEYDOWN_DATA_API = "keydown".concat(EVENT_KEY$8).concat(DATA_API_KEY$4);
  var EVENT_KEYUP_DATA_API = "keyup".concat(EVENT_KEY$8).concat(DATA_API_KEY$4);
  var CLASS_NAME_SHOW$6 = 'show';
  var CLASS_NAME_DROPUP = 'dropup';
  var CLASS_NAME_DROPEND = 'dropend';
  var CLASS_NAME_DROPSTART = 'dropstart';
  var CLASS_NAME_NAVBAR = 'navbar';
  var SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]';
  var SELECTOR_MENU = '.dropdown-menu';
  var SELECTOR_NAVBAR_NAV = '.navbar-nav';
  var SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
  var PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
  var PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
  var PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
  var PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
  var PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
  var PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
  var Default$8 = {
    offset: [0, 2],
    boundary: 'clippingParents',
    reference: 'toggle',
    display: 'dynamic',
    popperConfig: null,
    autoClose: true
  };
  var DefaultType$8 = {
    offset: '(array|string|function)',
    boundary: '(string|element)',
    reference: '(string|element|object)',
    display: 'string',
    popperConfig: '(null|object|function)',
    autoClose: '(boolean|string)'
  };
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Dropdown = /*#__PURE__*/function (_BaseComponent5) {
    _inherits(Dropdown, _BaseComponent5);
  
    var _super5 = _createSuper(Dropdown);
  
    function Dropdown(element, config) {
      var _this12;
  
      _classCallCheck(this, Dropdown);
  
      _this12 = _super5.call(this, element);
      _this12._popper = null;
      _this12._config = _this12._getConfig(config);
      _this12._menu = _this12._getMenuElement();
      _this12._inNavbar = _this12._detectNavbar();
      return _this12;
    } // Getters
  
  
    _createClass(Dropdown, [{
      key: "toggle",
      value: // Public
      function toggle() {
        return this._isShown() ? this.hide() : this.show();
      }
    }, {
      key: "show",
      value: function show() {
        if (isDisabled(this._element) || this._isShown(this._menu)) {
          return;
        }
  
        var relatedTarget = {
          relatedTarget: this._element
        };
        var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, relatedTarget);
  
        if (showEvent.defaultPrevented) {
          return;
        }
  
        var parent = Dropdown.getParentFromElement(this._element); // Totally disable Popper for Dropdowns in Navbar
  
        if (this._inNavbar) {
          Manipulator.setDataAttribute(this._menu, 'popper', 'none');
        } else {
          this._createPopper(parent);
        } // 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 && !parent.closest(SELECTOR_NAVBAR_NAV)) {
          var _ref4;
  
          (_ref4 = []).concat.apply(_ref4, _toConsumableArray(document.body.children)).forEach(function (elem) {
            return EventHandler.on(elem, 'mouseover', noop);
          });
        }
  
        this._element.focus();
  
        this._element.setAttribute('aria-expanded', true);
  
        this._menu.classList.add(CLASS_NAME_SHOW$6);
  
        this._element.classList.add(CLASS_NAME_SHOW$6);
  
        EventHandler.trigger(this._element, EVENT_SHOWN$4, relatedTarget);
      }
    }, {
      key: "hide",
      value: function hide() {
        if (isDisabled(this._element) || !this._isShown(this._menu)) {
          return;
        }
  
        var relatedTarget = {
          relatedTarget: this._element
        };
  
        this._completeHide(relatedTarget);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        if (this._popper) {
          this._popper.destroy();
        }
  
        _get(_getPrototypeOf(Dropdown.prototype), "dispose", this).call(this);
      }
    }, {
      key: "update",
      value: function update() {
        this._inNavbar = this._detectNavbar();
  
        if (this._popper) {
          this._popper.update();
        }
      } // Private
  
    }, {
      key: "_completeHide",
      value: function _completeHide(relatedTarget) {
        var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget);
  
        if (hideEvent.defaultPrevented) {
          return;
        } // 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 _ref5;
  
          (_ref5 = []).concat.apply(_ref5, _toConsumableArray(document.body.children)).forEach(function (elem) {
            return EventHandler.off(elem, 'mouseover', noop);
          });
        }
  
        if (this._popper) {
          this._popper.destroy();
        }
  
        this._menu.classList.remove(CLASS_NAME_SHOW$6);
  
        this._element.classList.remove(CLASS_NAME_SHOW$6);
  
        this._element.setAttribute('aria-expanded', 'false');
  
        Manipulator.removeDataAttribute(this._menu, 'popper');
        EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget);
      }
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, this.constructor.Default), Manipulator.getDataAttributes(this._element)), config);
        typeCheckConfig(NAME$9, config, this.constructor.DefaultType);
  
        if (_typeof(config.reference) === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
          // Popper virtual elements require a getBoundingClientRect method
          throw new TypeError("".concat(NAME$9.toUpperCase(), ": Option \"reference\" provided type \"object\" without a required \"getBoundingClientRect\" method."));
        }
  
        return config;
      }
    }, {
      key: "_createPopper",
      value: function _createPopper(parent) {
        if (typeof !(function webpackMissingModule() { var e = new Error("Cannot find module '@popperjs/core'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()) === 'undefined') {
          throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
        }
  
        var referenceElement = this._element;
  
        if (this._config.reference === 'parent') {
          referenceElement = parent;
        } else if (isElement(this._config.reference)) {
          referenceElement = getElement(this._config.reference);
        } else if (_typeof(this._config.reference) === 'object') {
          referenceElement = this._config.reference;
        }
  
        var popperConfig = this._getPopperConfig();
  
        var isDisplayStatic = popperConfig.modifiers.find(function (modifier) {
          return modifier.name === 'applyStyles' && modifier.enabled === false;
        });
        this._popper = !(function webpackMissingModule() { var e = new Error("Cannot find module '@popperjs/core'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())(referenceElement, this._menu, popperConfig);
  
        if (isDisplayStatic) {
          Manipulator.setDataAttribute(this._menu, 'popper', 'static');
        }
      }
    }, {
      key: "_isShown",
      value: function _isShown() {
        var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._element;
        return element.classList.contains(CLASS_NAME_SHOW$6);
      }
    }, {
      key: "_getMenuElement",
      value: function _getMenuElement() {
        return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
      }
    }, {
      key: "_getPlacement",
      value: function _getPlacement() {
        var parentDropdown = this._element.parentNode;
  
        if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
          return PLACEMENT_RIGHT;
        }
  
        if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
          return PLACEMENT_LEFT;
        } // We need to trim the value because custom properties can also include spaces
  
  
        var isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
  
        if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
          return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
        }
  
        return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
      }
    }, {
      key: "_detectNavbar",
      value: function _detectNavbar() {
        return this._element.closest(".".concat(CLASS_NAME_NAVBAR)) !== null;
      }
    }, {
      key: "_getOffset",
      value: function _getOffset() {
        var _this13 = this;
  
        var offset = this._config.offset;
  
        if (typeof offset === 'string') {
          return offset.split(',').map(function (val) {
            return Number.parseInt(val, 10);
          });
        }
  
        if (typeof offset === 'function') {
          return function (popperData) {
            return offset(popperData, _this13._element);
          };
        }
  
        return offset;
      }
    }, {
      key: "_getPopperConfig",
      value: function _getPopperConfig() {
        var defaultBsPopperConfig = {
          placement: this._getPlacement(),
          modifiers: [{
            name: 'preventOverflow',
            options: {
              boundary: this._config.boundary
            }
          }, {
            name: 'offset',
            options: {
              offset: this._getOffset()
            }
          }]
        }; // Disable Popper if we have a static display
  
        if (this._config.display === 'static') {
          defaultBsPopperConfig.modifiers = [{
            name: 'applyStyles',
            enabled: false
          }];
        }
  
        return _objectSpread(_objectSpread({}, defaultBsPopperConfig), typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig);
      }
    }, {
      key: "_selectMenuItem",
      value: function _selectMenuItem(_ref6) {
        var key = _ref6.key,
            target = _ref6.target;
        var items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
  
        if (!items.length) {
          return;
        } // if target isn't included in items (e.g. when expanding the dropdown)
        // allow cycling to get the last item in case key equals ARROW_UP_KEY
  
  
        getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus();
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$8;
      }
    }, {
      key: "DefaultType",
      get: function get() {
        return DefaultType$8;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$9;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Dropdown.getOrCreateInstance(this, config);
  
          if (typeof config !== 'string') {
            return;
          }
  
          if (typeof data[config] === 'undefined') {
            throw new TypeError("No method named \"".concat(config, "\""));
          }
  
          data[config]();
        });
      }
    }, {
      key: "clearMenus",
      value: function clearMenus(event) {
        if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1)) {
          return;
        }
  
        var toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$3);
  
        for (var i = 0, len = toggles.length; i < len; i++) {
          var context = Dropdown.getInstance(toggles[i]);
  
          if (!context || context._config.autoClose === false) {
            continue;
          }
  
          if (!context._isShown()) {
            continue;
          }
  
          var relatedTarget = {
            relatedTarget: context._element
          };
  
          if (event) {
            var composedPath = event.composedPath();
            var isMenuTarget = composedPath.includes(context._menu);
  
            if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
              continue;
            } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
  
  
            if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
              continue;
            }
  
            if (event.type === 'click') {
              relatedTarget.clickEvent = event;
            }
          }
  
          context._completeHide(relatedTarget);
        }
      }
    }, {
      key: "getParentFromElement",
      value: function getParentFromElement(element) {
        return getElementFromSelector(element) || element.parentNode;
      }
    }, {
      key: "dataApiKeydownHandler",
      value: function dataApiKeydownHandler(event) {
        // If not input/textarea:
        //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
        // If input/textarea:
        //  - If space key => not a dropdown command
        //  - If key is other than escape
        //    - If key is not up or down => not a dropdown command
        //    - If trigger inside the menu => not a dropdown command
        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)) {
          return;
        }
  
        var isActive = this.classList.contains(CLASS_NAME_SHOW$6);
  
        if (!isActive && event.key === ESCAPE_KEY$2) {
          return;
        }
  
        event.preventDefault();
        event.stopPropagation();
  
        if (isDisabled(this)) {
          return;
        }
  
        var getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
        var instance = Dropdown.getOrCreateInstance(getToggleButton);
  
        if (event.key === ESCAPE_KEY$2) {
          instance.hide();
          return;
        }
  
        if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
          if (!isActive) {
            instance.show();
          }
  
          instance._selectMenuItem(event);
  
          return;
        }
  
        if (!isActive || event.key === SPACE_KEY) {
          Dropdown.clearMenus();
        }
      }
    }]);
  
    return Dropdown;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
  EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
  EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
  EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
  EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
    event.preventDefault();
    Dropdown.getOrCreateInstance(this).toggle();
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Dropdown to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Dropdown);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): util/scrollBar.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
  var SELECTOR_STICKY_CONTENT = '.sticky-top';
  
  var ScrollBarHelper = /*#__PURE__*/function () {
    function ScrollBarHelper() {
      _classCallCheck(this, ScrollBarHelper);
  
      this._element = document.body;
    }
  
    _createClass(ScrollBarHelper, [{
      key: "getWidth",
      value: function getWidth() {
        // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
        var documentWidth = document.documentElement.clientWidth;
        return Math.abs(window.innerWidth - documentWidth);
      }
    }, {
      key: "hide",
      value: function hide() {
        var width = this.getWidth();
  
        this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width
  
  
        this._setElementAttributes(this._element, 'paddingRight', function (calculatedValue) {
          return calculatedValue + width;
        }); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
  
  
        this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', function (calculatedValue) {
          return calculatedValue + width;
        });
  
        this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', function (calculatedValue) {
          return calculatedValue - width;
        });
      }
    }, {
      key: "_disableOverFlow",
      value: function _disableOverFlow() {
        this._saveInitialAttribute(this._element, 'overflow');
  
        this._element.style.overflow = 'hidden';
      }
    }, {
      key: "_setElementAttributes",
      value: function _setElementAttributes(selector, styleProp, callback) {
        var _this14 = this;
  
        var scrollbarWidth = this.getWidth();
  
        var manipulationCallBack = function manipulationCallBack(element) {
          if (element !== _this14._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
            return;
          }
  
          _this14._saveInitialAttribute(element, styleProp);
  
          var calculatedValue = window.getComputedStyle(element)[styleProp];
          element.style[styleProp] = "".concat(callback(Number.parseFloat(calculatedValue)), "px");
        };
  
        this._applyManipulationCallback(selector, manipulationCallBack);
      }
    }, {
      key: "reset",
      value: function reset() {
        this._resetElementAttributes(this._element, 'overflow');
  
        this._resetElementAttributes(this._element, 'paddingRight');
  
        this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
  
        this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
      }
    }, {
      key: "_saveInitialAttribute",
      value: function _saveInitialAttribute(element, styleProp) {
        var actualValue = element.style[styleProp];
  
        if (actualValue) {
          Manipulator.setDataAttribute(element, styleProp, actualValue);
        }
      }
    }, {
      key: "_resetElementAttributes",
      value: function _resetElementAttributes(selector, styleProp) {
        var manipulationCallBack = function manipulationCallBack(element) {
          var value = Manipulator.getDataAttribute(element, styleProp);
  
          if (typeof value === 'undefined') {
            element.style.removeProperty(styleProp);
          } else {
            Manipulator.removeDataAttribute(element, styleProp);
            element.style[styleProp] = value;
          }
        };
  
        this._applyManipulationCallback(selector, manipulationCallBack);
      }
    }, {
      key: "_applyManipulationCallback",
      value: function _applyManipulationCallback(selector, callBack) {
        if (isElement(selector)) {
          callBack(selector);
        } else {
          SelectorEngine.find(selector, this._element).forEach(callBack);
        }
      }
    }, {
      key: "isOverflowing",
      value: function isOverflowing() {
        return this.getWidth() > 0;
      }
    }]);
  
    return ScrollBarHelper;
  }();
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): util/backdrop.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  
  var Default$7 = {
    className: 'modal-backdrop',
    isVisible: true,
    // if false, we use the backdrop helper without adding any element to the dom
    isAnimated: false,
    rootElement: 'body',
    // give the choice to place backdrop under different elements
    clickCallback: null
  };
  var DefaultType$7 = {
    className: 'string',
    isVisible: 'boolean',
    isAnimated: 'boolean',
    rootElement: '(element|string)',
    clickCallback: '(function|null)'
  };
  var NAME$8 = 'backdrop';
  var CLASS_NAME_FADE$4 = 'fade';
  var CLASS_NAME_SHOW$5 = 'show';
  var EVENT_MOUSEDOWN = "mousedown.bs.".concat(NAME$8);
  
  var Backdrop = /*#__PURE__*/function () {
    function Backdrop(config) {
      _classCallCheck(this, Backdrop);
  
      this._config = this._getConfig(config);
      this._isAppended = false;
      this._element = null;
    }
  
    _createClass(Backdrop, [{
      key: "show",
      value: function show(callback) {
        if (!this._config.isVisible) {
          execute(callback);
          return;
        }
  
        this._append();
  
        if (this._config.isAnimated) {
          reflow(this._getElement());
        }
  
        this._getElement().classList.add(CLASS_NAME_SHOW$5);
  
        this._emulateAnimation(function () {
          execute(callback);
        });
      }
    }, {
      key: "hide",
      value: function hide(callback) {
        var _this15 = this;
  
        if (!this._config.isVisible) {
          execute(callback);
          return;
        }
  
        this._getElement().classList.remove(CLASS_NAME_SHOW$5);
  
        this._emulateAnimation(function () {
          _this15.dispose();
  
          execute(callback);
        });
      } // Private
  
    }, {
      key: "_getElement",
      value: function _getElement() {
        if (!this._element) {
          var backdrop = document.createElement('div');
          backdrop.className = this._config.className;
  
          if (this._config.isAnimated) {
            backdrop.classList.add(CLASS_NAME_FADE$4);
          }
  
          this._element = backdrop;
        }
  
        return this._element;
      }
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread({}, Default$7), _typeof(config) === 'object' ? config : {}); // use getElement() with the default "body" to get a fresh Element on each instantiation
  
        config.rootElement = getElement(config.rootElement);
        typeCheckConfig(NAME$8, config, DefaultType$7);
        return config;
      }
    }, {
      key: "_append",
      value: function _append() {
        var _this16 = this;
  
        if (this._isAppended) {
          return;
        }
  
        this._config.rootElement.append(this._getElement());
  
        EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, function () {
          execute(_this16._config.clickCallback);
        });
        this._isAppended = true;
      }
    }, {
      key: "dispose",
      value: function dispose() {
        if (!this._isAppended) {
          return;
        }
  
        EventHandler.off(this._element, EVENT_MOUSEDOWN);
  
        this._element.remove();
  
        this._isAppended = false;
      }
    }, {
      key: "_emulateAnimation",
      value: function _emulateAnimation(callback) {
        executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
      }
    }]);
  
    return Backdrop;
  }();
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): util/focustrap.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  
  var Default$6 = {
    trapElement: null,
    // The element to trap focus inside of
    autofocus: true
  };
  var DefaultType$6 = {
    trapElement: 'element',
    autofocus: 'boolean'
  };
  var NAME$7 = 'focustrap';
  var DATA_KEY$7 = 'bs.focustrap';
  var EVENT_KEY$7 = ".".concat(DATA_KEY$7);
  var EVENT_FOCUSIN$1 = "focusin".concat(EVENT_KEY$7);
  var EVENT_KEYDOWN_TAB = "keydown.tab".concat(EVENT_KEY$7);
  var TAB_KEY = 'Tab';
  var TAB_NAV_FORWARD = 'forward';
  var TAB_NAV_BACKWARD = 'backward';
  
  var FocusTrap = /*#__PURE__*/function () {
    function FocusTrap(config) {
      _classCallCheck(this, FocusTrap);
  
      this._config = this._getConfig(config);
      this._isActive = false;
      this._lastTabNavDirection = null;
    }
  
    _createClass(FocusTrap, [{
      key: "activate",
      value: function activate() {
        var _this17 = this;
  
        var _this$_config = this._config,
            trapElement = _this$_config.trapElement,
            autofocus = _this$_config.autofocus;
  
        if (this._isActive) {
          return;
        }
  
        if (autofocus) {
          trapElement.focus();
        }
  
        EventHandler.off(document, EVENT_KEY$7); // guard against infinite focus loop
  
        EventHandler.on(document, EVENT_FOCUSIN$1, function (event) {
          return _this17._handleFocusin(event);
        });
        EventHandler.on(document, EVENT_KEYDOWN_TAB, function (event) {
          return _this17._handleKeydown(event);
        });
        this._isActive = true;
      }
    }, {
      key: "deactivate",
      value: function deactivate() {
        if (!this._isActive) {
          return;
        }
  
        this._isActive = false;
        EventHandler.off(document, EVENT_KEY$7);
      } // Private
  
    }, {
      key: "_handleFocusin",
      value: function _handleFocusin(event) {
        var target = event.target;
        var trapElement = this._config.trapElement;
  
        if (target === document || target === trapElement || trapElement.contains(target)) {
          return;
        }
  
        var elements = SelectorEngine.focusableChildren(trapElement);
  
        if (elements.length === 0) {
          trapElement.focus();
        } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
          elements[elements.length - 1].focus();
        } else {
          elements[0].focus();
        }
      }
    }, {
      key: "_handleKeydown",
      value: function _handleKeydown(event) {
        if (event.key !== TAB_KEY) {
          return;
        }
  
        this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
      }
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread({}, Default$6), _typeof(config) === 'object' ? config : {});
        typeCheckConfig(NAME$7, config, DefaultType$6);
        return config;
      }
    }]);
  
    return FocusTrap;
  }();
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): modal.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  
  var NAME$6 = 'modal';
  var DATA_KEY$6 = 'bs.modal';
  var EVENT_KEY$6 = ".".concat(DATA_KEY$6);
  var DATA_API_KEY$3 = '.data-api';
  var ESCAPE_KEY$1 = 'Escape';
  var Default$5 = {
    backdrop: true,
    keyboard: true,
    focus: true
  };
  var DefaultType$5 = {
    backdrop: '(boolean|string)',
    keyboard: 'boolean',
    focus: 'boolean'
  };
  var EVENT_HIDE$3 = "hide".concat(EVENT_KEY$6);
  var EVENT_HIDE_PREVENTED = "hidePrevented".concat(EVENT_KEY$6);
  var EVENT_HIDDEN$3 = "hidden".concat(EVENT_KEY$6);
  var EVENT_SHOW$3 = "show".concat(EVENT_KEY$6);
  var EVENT_SHOWN$3 = "shown".concat(EVENT_KEY$6);
  var EVENT_RESIZE = "resize".concat(EVENT_KEY$6);
  var EVENT_CLICK_DISMISS = "click.dismiss".concat(EVENT_KEY$6);
  var EVENT_KEYDOWN_DISMISS$1 = "keydown.dismiss".concat(EVENT_KEY$6);
  var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss".concat(EVENT_KEY$6);
  var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss".concat(EVENT_KEY$6);
  var EVENT_CLICK_DATA_API$2 = "click".concat(EVENT_KEY$6).concat(DATA_API_KEY$3);
  var CLASS_NAME_OPEN = 'modal-open';
  var CLASS_NAME_FADE$3 = 'fade';
  var CLASS_NAME_SHOW$4 = 'show';
  var CLASS_NAME_STATIC = 'modal-static';
  var OPEN_SELECTOR$1 = '.modal.show';
  var SELECTOR_DIALOG = '.modal-dialog';
  var SELECTOR_MODAL_BODY = '.modal-body';
  var SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Modal = /*#__PURE__*/function (_BaseComponent6) {
    _inherits(Modal, _BaseComponent6);
  
    var _super6 = _createSuper(Modal);
  
    function Modal(element, config) {
      var _this18;
  
      _classCallCheck(this, Modal);
  
      _this18 = _super6.call(this, element);
      _this18._config = _this18._getConfig(config);
      _this18._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, _this18._element);
      _this18._backdrop = _this18._initializeBackDrop();
      _this18._focustrap = _this18._initializeFocusTrap();
      _this18._isShown = false;
      _this18._ignoreBackdropClick = false;
      _this18._isTransitioning = false;
      _this18._scrollBar = new ScrollBarHelper();
      return _this18;
    } // Getters
  
  
    _createClass(Modal, [{
      key: "toggle",
      value: // Public
      function toggle(relatedTarget) {
        return this._isShown ? this.hide() : this.show(relatedTarget);
      }
    }, {
      key: "show",
      value: function show(relatedTarget) {
        var _this19 = this;
  
        if (this._isShown || this._isTransitioning) {
          return;
        }
  
        var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
          relatedTarget: relatedTarget
        });
  
        if (showEvent.defaultPrevented) {
          return;
        }
  
        this._isShown = true;
  
        if (this._isAnimated()) {
          this._isTransitioning = true;
        }
  
        this._scrollBar.hide();
  
        document.body.classList.add(CLASS_NAME_OPEN);
  
        this._adjustDialog();
  
        this._setEscapeEvent();
  
        this._setResizeEvent();
  
        EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, function () {
          EventHandler.one(_this19._element, EVENT_MOUSEUP_DISMISS, function (event) {
            if (event.target === _this19._element) {
              _this19._ignoreBackdropClick = true;
            }
          });
        });
  
        this._showBackdrop(function () {
          return _this19._showElement(relatedTarget);
        });
      }
    }, {
      key: "hide",
      value: function hide() {
        var _this20 = this;
  
        if (!this._isShown || this._isTransitioning) {
          return;
        }
  
        var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        this._isShown = false;
  
        var isAnimated = this._isAnimated();
  
        if (isAnimated) {
          this._isTransitioning = true;
        }
  
        this._setEscapeEvent();
  
        this._setResizeEvent();
  
        this._focustrap.deactivate();
  
        this._element.classList.remove(CLASS_NAME_SHOW$4);
  
        EventHandler.off(this._element, EVENT_CLICK_DISMISS);
        EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
  
        this._queueCallback(function () {
          return _this20._hideModal();
        }, this._element, isAnimated);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        [window, this._dialog].forEach(function (htmlElement) {
          return EventHandler.off(htmlElement, EVENT_KEY$6);
        });
  
        this._backdrop.dispose();
  
        this._focustrap.deactivate();
  
        _get(_getPrototypeOf(Modal.prototype), "dispose", this).call(this);
      }
    }, {
      key: "handleUpdate",
      value: function handleUpdate() {
        this._adjustDialog();
      } // Private
  
    }, {
      key: "_initializeBackDrop",
      value: function _initializeBackDrop() {
        return new Backdrop({
          isVisible: Boolean(this._config.backdrop),
          // 'static' option will be translated to true, and booleans will keep their value
          isAnimated: this._isAnimated()
        });
      }
    }, {
      key: "_initializeFocusTrap",
      value: function _initializeFocusTrap() {
        return new FocusTrap({
          trapElement: this._element
        });
      }
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default$5), Manipulator.getDataAttributes(this._element)), _typeof(config) === 'object' ? config : {});
        typeCheckConfig(NAME$6, config, DefaultType$5);
        return config;
      }
    }, {
      key: "_showElement",
      value: function _showElement(relatedTarget) {
        var _this21 = this;
  
        var isAnimated = this._isAnimated();
  
        var modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
  
        if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
          // Don't move modal's DOM position
          document.body.append(this._element);
        }
  
        this._element.style.display = 'block';
  
        this._element.removeAttribute('aria-hidden');
  
        this._element.setAttribute('aria-modal', true);
  
        this._element.setAttribute('role', 'dialog');
  
        this._element.scrollTop = 0;
  
        if (modalBody) {
          modalBody.scrollTop = 0;
        }
  
        if (isAnimated) {
          reflow(this._element);
        }
  
        this._element.classList.add(CLASS_NAME_SHOW$4);
  
        var transitionComplete = function transitionComplete() {
          if (_this21._config.focus) {
            _this21._focustrap.activate();
          }
  
          _this21._isTransitioning = false;
          EventHandler.trigger(_this21._element, EVENT_SHOWN$3, {
            relatedTarget: relatedTarget
          });
        };
  
        this._queueCallback(transitionComplete, this._dialog, isAnimated);
      }
    }, {
      key: "_setEscapeEvent",
      value: function _setEscapeEvent() {
        var _this22 = this;
  
        if (this._isShown) {
          EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, function (event) {
            if (_this22._config.keyboard && event.key === ESCAPE_KEY$1) {
              event.preventDefault();
  
              _this22.hide();
            } else if (!_this22._config.keyboard && event.key === ESCAPE_KEY$1) {
              _this22._triggerBackdropTransition();
            }
          });
        } else {
          EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS$1);
        }
      }
    }, {
      key: "_setResizeEvent",
      value: function _setResizeEvent() {
        var _this23 = this;
  
        if (this._isShown) {
          EventHandler.on(window, EVENT_RESIZE, function () {
            return _this23._adjustDialog();
          });
        } else {
          EventHandler.off(window, EVENT_RESIZE);
        }
      }
    }, {
      key: "_hideModal",
      value: function _hideModal() {
        var _this24 = this;
  
        this._element.style.display = 'none';
  
        this._element.setAttribute('aria-hidden', true);
  
        this._element.removeAttribute('aria-modal');
  
        this._element.removeAttribute('role');
  
        this._isTransitioning = false;
  
        this._backdrop.hide(function () {
          document.body.classList.remove(CLASS_NAME_OPEN);
  
          _this24._resetAdjustments();
  
          _this24._scrollBar.reset();
  
          EventHandler.trigger(_this24._element, EVENT_HIDDEN$3);
        });
      }
    }, {
      key: "_showBackdrop",
      value: function _showBackdrop(callback) {
        var _this25 = this;
  
        EventHandler.on(this._element, EVENT_CLICK_DISMISS, function (event) {
          if (_this25._ignoreBackdropClick) {
            _this25._ignoreBackdropClick = false;
            return;
          }
  
          if (event.target !== event.currentTarget) {
            return;
          }
  
          if (_this25._config.backdrop === true) {
            _this25.hide();
          } else if (_this25._config.backdrop === 'static') {
            _this25._triggerBackdropTransition();
          }
        });
  
        this._backdrop.show(callback);
      }
    }, {
      key: "_isAnimated",
      value: function _isAnimated() {
        return this._element.classList.contains(CLASS_NAME_FADE$3);
      }
    }, {
      key: "_triggerBackdropTransition",
      value: function _triggerBackdropTransition() {
        var _this26 = this;
  
        var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        var _this$_element = this._element,
            classList = _this$_element.classList,
            scrollHeight = _this$_element.scrollHeight,
            style = _this$_element.style;
        var isModalOverflowing = scrollHeight > document.documentElement.clientHeight; // return if the following background transition hasn't yet completed
  
        if (!isModalOverflowing && style.overflowY === 'hidden' || classList.contains(CLASS_NAME_STATIC)) {
          return;
        }
  
        if (!isModalOverflowing) {
          style.overflowY = 'hidden';
        }
  
        classList.add(CLASS_NAME_STATIC);
  
        this._queueCallback(function () {
          classList.remove(CLASS_NAME_STATIC);
  
          if (!isModalOverflowing) {
            _this26._queueCallback(function () {
              style.overflowY = '';
            }, _this26._dialog);
          }
        }, this._dialog);
  
        this._element.focus();
      } // ----------------------------------------------------------------------
      // the following methods are used to handle overflowing modals
      // ----------------------------------------------------------------------
  
    }, {
      key: "_adjustDialog",
      value: function _adjustDialog() {
        var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
  
        var scrollbarWidth = this._scrollBar.getWidth();
  
        var isBodyOverflowing = scrollbarWidth > 0;
  
        if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) {
          this._element.style.paddingLeft = "".concat(scrollbarWidth, "px");
        }
  
        if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) {
          this._element.style.paddingRight = "".concat(scrollbarWidth, "px");
        }
      }
    }, {
      key: "_resetAdjustments",
      value: function _resetAdjustments() {
        this._element.style.paddingLeft = '';
        this._element.style.paddingRight = '';
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$5;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$6;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config, relatedTarget) {
        return this.each(function () {
          var data = Modal.getOrCreateInstance(this, config);
  
          if (typeof config !== 'string') {
            return;
          }
  
          if (typeof data[config] === 'undefined') {
            throw new TypeError("No method named \"".concat(config, "\""));
          }
  
          data[config](relatedTarget);
        });
      }
    }]);
  
    return Modal;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
    var _this27 = this;
  
    var target = getElementFromSelector(this);
  
    if (['A', 'AREA'].includes(this.tagName)) {
      event.preventDefault();
    }
  
    EventHandler.one(target, EVENT_SHOW$3, function (showEvent) {
      if (showEvent.defaultPrevented) {
        // only register focus restorer if modal will actually get shown
        return;
      }
  
      EventHandler.one(target, EVENT_HIDDEN$3, function () {
        if (isVisible(_this27)) {
          _this27.focus();
        }
      });
    }); // avoid conflict when clicking moddal toggler while another one is open
  
    var allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
  
    if (allReadyOpen) {
      Modal.getInstance(allReadyOpen).hide();
    }
  
    var data = Modal.getOrCreateInstance(target);
    data.toggle(this);
  });
  enableDismissTrigger(Modal);
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Modal to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Modal);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): offcanvas.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$5 = 'offcanvas';
  var DATA_KEY$5 = 'bs.offcanvas';
  var EVENT_KEY$5 = ".".concat(DATA_KEY$5);
  var DATA_API_KEY$2 = '.data-api';
  var EVENT_LOAD_DATA_API$1 = "load".concat(EVENT_KEY$5).concat(DATA_API_KEY$2);
  var ESCAPE_KEY = 'Escape';
  var Default$4 = {
    backdrop: true,
    keyboard: true,
    scroll: false
  };
  var DefaultType$4 = {
    backdrop: 'boolean',
    keyboard: 'boolean',
    scroll: 'boolean'
  };
  var CLASS_NAME_SHOW$3 = 'show';
  var CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
  var OPEN_SELECTOR = '.offcanvas.show';
  var EVENT_SHOW$2 = "show".concat(EVENT_KEY$5);
  var EVENT_SHOWN$2 = "shown".concat(EVENT_KEY$5);
  var EVENT_HIDE$2 = "hide".concat(EVENT_KEY$5);
  var EVENT_HIDDEN$2 = "hidden".concat(EVENT_KEY$5);
  var EVENT_CLICK_DATA_API$1 = "click".concat(EVENT_KEY$5).concat(DATA_API_KEY$2);
  var EVENT_KEYDOWN_DISMISS = "keydown.dismiss".concat(EVENT_KEY$5);
  var SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Offcanvas = /*#__PURE__*/function (_BaseComponent7) {
    _inherits(Offcanvas, _BaseComponent7);
  
    var _super7 = _createSuper(Offcanvas);
  
    function Offcanvas(element, config) {
      var _this28;
  
      _classCallCheck(this, Offcanvas);
  
      _this28 = _super7.call(this, element);
      _this28._config = _this28._getConfig(config);
      _this28._isShown = false;
      _this28._backdrop = _this28._initializeBackDrop();
      _this28._focustrap = _this28._initializeFocusTrap();
  
      _this28._addEventListeners();
  
      return _this28;
    } // Getters
  
  
    _createClass(Offcanvas, [{
      key: "toggle",
      value: // Public
      function toggle(relatedTarget) {
        return this._isShown ? this.hide() : this.show(relatedTarget);
      }
    }, {
      key: "show",
      value: function show(relatedTarget) {
        var _this29 = this;
  
        if (this._isShown) {
          return;
        }
  
        var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, {
          relatedTarget: relatedTarget
        });
  
        if (showEvent.defaultPrevented) {
          return;
        }
  
        this._isShown = true;
        this._element.style.visibility = 'visible';
  
        this._backdrop.show();
  
        if (!this._config.scroll) {
          new ScrollBarHelper().hide();
        }
  
        this._element.removeAttribute('aria-hidden');
  
        this._element.setAttribute('aria-modal', true);
  
        this._element.setAttribute('role', 'dialog');
  
        this._element.classList.add(CLASS_NAME_SHOW$3);
  
        var completeCallBack = function completeCallBack() {
          if (!_this29._config.scroll) {
            _this29._focustrap.activate();
          }
  
          EventHandler.trigger(_this29._element, EVENT_SHOWN$2, {
            relatedTarget: relatedTarget
          });
        };
  
        this._queueCallback(completeCallBack, this._element, true);
      }
    }, {
      key: "hide",
      value: function hide() {
        var _this30 = this;
  
        if (!this._isShown) {
          return;
        }
  
        var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2);
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        this._focustrap.deactivate();
  
        this._element.blur();
  
        this._isShown = false;
  
        this._element.classList.remove(CLASS_NAME_SHOW$3);
  
        this._backdrop.hide();
  
        var completeCallback = function completeCallback() {
          _this30._element.setAttribute('aria-hidden', true);
  
          _this30._element.removeAttribute('aria-modal');
  
          _this30._element.removeAttribute('role');
  
          _this30._element.style.visibility = 'hidden';
  
          if (!_this30._config.scroll) {
            new ScrollBarHelper().reset();
          }
  
          EventHandler.trigger(_this30._element, EVENT_HIDDEN$2);
        };
  
        this._queueCallback(completeCallback, this._element, true);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        this._backdrop.dispose();
  
        this._focustrap.deactivate();
  
        _get(_getPrototypeOf(Offcanvas.prototype), "dispose", this).call(this);
      } // Private
  
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default$4), Manipulator.getDataAttributes(this._element)), _typeof(config) === 'object' ? config : {});
        typeCheckConfig(NAME$5, config, DefaultType$4);
        return config;
      }
    }, {
      key: "_initializeBackDrop",
      value: function _initializeBackDrop() {
        var _this31 = this;
  
        return new Backdrop({
          className: CLASS_NAME_BACKDROP,
          isVisible: this._config.backdrop,
          isAnimated: true,
          rootElement: this._element.parentNode,
          clickCallback: function clickCallback() {
            return _this31.hide();
          }
        });
      }
    }, {
      key: "_initializeFocusTrap",
      value: function _initializeFocusTrap() {
        return new FocusTrap({
          trapElement: this._element
        });
      }
    }, {
      key: "_addEventListeners",
      value: function _addEventListeners() {
        var _this32 = this;
  
        EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, function (event) {
          if (_this32._config.keyboard && event.key === ESCAPE_KEY) {
            _this32.hide();
          }
        });
      } // Static
  
    }], [{
      key: "NAME",
      get: function get() {
        return NAME$5;
      }
    }, {
      key: "Default",
      get: function get() {
        return Default$4;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Offcanvas.getOrCreateInstance(this, config);
  
          if (typeof config !== 'string') {
            return;
          }
  
          if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
            throw new TypeError("No method named \"".concat(config, "\""));
          }
  
          data[config](this);
        });
      }
    }]);
  
    return Offcanvas;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
    var _this33 = this;
  
    var target = getElementFromSelector(this);
  
    if (['A', 'AREA'].includes(this.tagName)) {
      event.preventDefault();
    }
  
    if (isDisabled(this)) {
      return;
    }
  
    EventHandler.one(target, EVENT_HIDDEN$2, function () {
      // focus on trigger when it is closed
      if (isVisible(_this33)) {
        _this33.focus();
      }
    }); // avoid conflict when clicking a toggler of an offcanvas, while another is open
  
    var allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
  
    if (allReadyOpen && allReadyOpen !== target) {
      Offcanvas.getInstance(allReadyOpen).hide();
    }
  
    var data = Offcanvas.getOrCreateInstance(target);
    data.toggle(this);
  });
  EventHandler.on(window, EVENT_LOAD_DATA_API$1, function () {
    return SelectorEngine.find(OPEN_SELECTOR).forEach(function (el) {
      return Offcanvas.getOrCreateInstance(el).show();
    });
  });
  enableDismissTrigger(Offcanvas);
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   */
  
  defineJQueryPlugin(Offcanvas);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): util/sanitizer.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  var uriAttributes = 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 https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
   */
  
  var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i;
  /**
   * A pattern that matches safe data URLs. Only matches image, video and audio types.
   *
   * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/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(attribute, allowedAttributeList) {
    var attributeName = attribute.nodeName.toLowerCase();
  
    if (allowedAttributeList.includes(attributeName)) {
      if (uriAttributes.has(attributeName)) {
        return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue));
      }
  
      return true;
    }
  
    var regExp = allowedAttributeList.filter(function (attributeRegex) {
      return attributeRegex instanceof RegExp;
    }); // Check if a regular expression validates the attribute.
  
    for (var i = 0, len = regExp.length; i < len; i++) {
      if (regExp[i].test(attributeName)) {
        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 _ref7;
  
    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 elements = (_ref7 = []).concat.apply(_ref7, _toConsumableArray(createdDocument.body.querySelectorAll('*')));
  
    var _loop = function _loop(i, len) {
      var _ref8;
  
      var element = elements[i];
      var elementName = element.nodeName.toLowerCase();
  
      if (!Object.keys(allowList).includes(elementName)) {
        element.remove();
        return "continue";
      }
  
      var attributeList = (_ref8 = []).concat.apply(_ref8, _toConsumableArray(element.attributes));
  
      var allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
      attributeList.forEach(function (attribute) {
        if (!allowedAttribute(attribute, allowedAttributes)) {
          element.removeAttribute(attribute.nodeName);
        }
      });
    };
  
    for (var i = 0, len = elements.length; i < len; i++) {
      var _ret = _loop(i, len);
  
      if (_ret === "continue") continue;
    }
  
    return createdDocument.body.innerHTML;
  }
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): tooltip.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  
  var NAME$4 = 'tooltip';
  var DATA_KEY$4 = 'bs.tooltip';
  var EVENT_KEY$4 = ".".concat(DATA_KEY$4);
  var CLASS_PREFIX$1 = 'bs-tooltip';
  var DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
  var DefaultType$3 = {
    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)'
  };
  var AttachmentMap = {
    AUTO: 'auto',
    TOP: 'top',
    RIGHT: isRTL() ? 'left' : 'right',
    BOTTOM: 'bottom',
    LEFT: isRTL() ? 'right' : 'left'
  };
  var Default$3 = {
    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',
    offset: [0, 0],
    container: false,
    fallbackPlacements: ['top', 'right', 'bottom', 'left'],
    boundary: 'clippingParents',
    customClass: '',
    sanitize: true,
    sanitizeFn: null,
    allowList: DefaultAllowlist,
    popperConfig: null
  };
  var Event$2 = {
    HIDE: "hide".concat(EVENT_KEY$4),
    HIDDEN: "hidden".concat(EVENT_KEY$4),
    SHOW: "show".concat(EVENT_KEY$4),
    SHOWN: "shown".concat(EVENT_KEY$4),
    INSERTED: "inserted".concat(EVENT_KEY$4),
    CLICK: "click".concat(EVENT_KEY$4),
    FOCUSIN: "focusin".concat(EVENT_KEY$4),
    FOCUSOUT: "focusout".concat(EVENT_KEY$4),
    MOUSEENTER: "mouseenter".concat(EVENT_KEY$4),
    MOUSELEAVE: "mouseleave".concat(EVENT_KEY$4)
  };
  var CLASS_NAME_FADE$2 = 'fade';
  var CLASS_NAME_MODAL = 'modal';
  var CLASS_NAME_SHOW$2 = 'show';
  var HOVER_STATE_SHOW = 'show';
  var HOVER_STATE_OUT = 'out';
  var SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
  var SELECTOR_MODAL = ".".concat(CLASS_NAME_MODAL);
  var EVENT_MODAL_HIDE = 'hide.bs.modal';
  var TRIGGER_HOVER = 'hover';
  var TRIGGER_FOCUS = 'focus';
  var TRIGGER_CLICK = 'click';
  var TRIGGER_MANUAL = 'manual';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Tooltip = /*#__PURE__*/function (_BaseComponent8) {
    _inherits(Tooltip, _BaseComponent8);
  
    var _super8 = _createSuper(Tooltip);
  
    function Tooltip(element, config) {
      var _this34;
  
      _classCallCheck(this, Tooltip);
  
      if (typeof !(function webpackMissingModule() { var e = new Error("Cannot find module '@popperjs/core'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()) === 'undefined') {
        throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
      }
  
      _this34 = _super8.call(this, element); // private
  
      _this34._isEnabled = true;
      _this34._timeout = 0;
      _this34._hoverState = '';
      _this34._activeTrigger = {};
      _this34._popper = null; // Protected
  
      _this34._config = _this34._getConfig(config);
      _this34.tip = null;
  
      _this34._setListeners();
  
      return _this34;
    } // Getters
  
  
    _createClass(Tooltip, [{
      key: "enable",
      value: // Public
      function enable() {
        this._isEnabled = true;
      }
    }, {
      key: "disable",
      value: function disable() {
        this._isEnabled = false;
      }
    }, {
      key: "toggleEnabled",
      value: function toggleEnabled() {
        this._isEnabled = !this._isEnabled;
      }
    }, {
      key: "toggle",
      value: function toggle(event) {
        if (!this._isEnabled) {
          return;
        }
  
        if (event) {
          var context = this._initializeOnDelegatedTarget(event);
  
          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$2)) {
            this._leave(null, this);
  
            return;
          }
  
          this._enter(null, this);
        }
      }
    }, {
      key: "dispose",
      value: function dispose() {
        clearTimeout(this._timeout);
        EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
  
        if (this.tip) {
          this.tip.remove();
        }
  
        this._disposePopper();
  
        _get(_getPrototypeOf(Tooltip.prototype), "dispose", this).call(this);
      }
    }, {
      key: "show",
      value: function show() {
        var _this35 = this;
  
        if (this._element.style.display === 'none') {
          throw new Error('Please use show on visible elements');
        }
  
        if (!(this.isWithContent() && this._isEnabled)) {
          return;
        }
  
        var showEvent = EventHandler.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;
        } // A trick to recreate a tooltip in case a new title is given by using the NOT documented `data-bs-original-title`
        // This will be removed later in favor of a `setContent` method
  
  
        if (this.constructor.NAME === 'tooltip' && this.tip && this.getTitle() !== this.tip.querySelector(SELECTOR_TOOLTIP_INNER).innerHTML) {
          this._disposePopper();
  
          this.tip.remove();
          this.tip = null;
        }
  
        var tip = this.getTipElement();
        var tipId = getUID(this.constructor.NAME);
        tip.setAttribute('id', tipId);
  
        this._element.setAttribute('aria-describedby', tipId);
  
        if (this._config.animation) {
          tip.classList.add(CLASS_NAME_FADE$2);
        }
  
        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._config.container;
        Data.set(tip, this.constructor.DATA_KEY, this);
  
        if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
          container.append(tip);
          EventHandler.trigger(this._element, this.constructor.Event.INSERTED);
        }
  
        if (this._popper) {
          this._popper.update();
        } else {
          this._popper = !(function webpackMissingModule() { var e = new Error("Cannot find module '@popperjs/core'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())(this._element, tip, this._getPopperConfig(attachment));
        }
  
        tip.classList.add(CLASS_NAME_SHOW$2);
  
        var customClass = this._resolvePossibleFunction(this._config.customClass);
  
        if (customClass) {
          var _tip$classList;
  
          (_tip$classList = tip.classList).add.apply(_tip$classList, _toConsumableArray(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 _ref9;
  
          (_ref9 = []).concat.apply(_ref9, _toConsumableArray(document.body.children)).forEach(function (element) {
            EventHandler.on(element, 'mouseover', noop);
          });
        }
  
        var complete = function complete() {
          var prevHoverState = _this35._hoverState;
          _this35._hoverState = null;
          EventHandler.trigger(_this35._element, _this35.constructor.Event.SHOWN);
  
          if (prevHoverState === HOVER_STATE_OUT) {
            _this35._leave(null, _this35);
          }
        };
  
        var isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
  
        this._queueCallback(complete, this.tip, isAnimated);
      }
    }, {
      key: "hide",
      value: function hide() {
        var _this36 = this;
  
        if (!this._popper) {
          return;
        }
  
        var tip = this.getTipElement();
  
        var complete = function complete() {
          if (_this36._isWithActiveTrigger()) {
            return;
          }
  
          if (_this36._hoverState !== HOVER_STATE_SHOW) {
            tip.remove();
          }
  
          _this36._cleanTipClass();
  
          _this36._element.removeAttribute('aria-describedby');
  
          EventHandler.trigger(_this36._element, _this36.constructor.Event.HIDDEN);
  
          _this36._disposePopper();
        };
  
        var hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE);
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        tip.classList.remove(CLASS_NAME_SHOW$2); // 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 _ref10;
  
          (_ref10 = []).concat.apply(_ref10, _toConsumableArray(document.body.children)).forEach(function (element) {
            return EventHandler.off(element, 'mouseover', noop);
          });
        }
  
        this._activeTrigger[TRIGGER_CLICK] = false;
        this._activeTrigger[TRIGGER_FOCUS] = false;
        this._activeTrigger[TRIGGER_HOVER] = false;
        var isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
  
        this._queueCallback(complete, this.tip, isAnimated);
  
        this._hoverState = '';
      }
    }, {
      key: "update",
      value: function update() {
        if (this._popper !== null) {
          this._popper.update();
        }
      } // Protected
  
    }, {
      key: "isWithContent",
      value: function isWithContent() {
        return Boolean(this.getTitle());
      }
    }, {
      key: "getTipElement",
      value: function getTipElement() {
        if (this.tip) {
          return this.tip;
        }
  
        var element = document.createElement('div');
        element.innerHTML = this._config.template;
        var tip = element.children[0];
        this.setContent(tip);
        tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
        this.tip = tip;
        return this.tip;
      }
    }, {
      key: "setContent",
      value: function setContent(tip) {
        this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TOOLTIP_INNER);
      }
    }, {
      key: "_sanitizeAndSetContent",
      value: function _sanitizeAndSetContent(template, content, selector) {
        var templateElement = SelectorEngine.findOne(selector, template);
  
        if (!content && templateElement) {
          templateElement.remove();
          return;
        } // we use append for html objects to maintain js events
  
  
        this.setElementContent(templateElement, content);
      }
    }, {
      key: "setElementContent",
      value: function setElementContent(element, content) {
        if (element === null) {
          return;
        }
  
        if (isElement(content)) {
          content = getElement(content); // content is a DOM node or a jQuery
  
          if (this._config.html) {
            if (content.parentNode !== element) {
              element.innerHTML = '';
              element.append(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;
        }
      }
    }, {
      key: "getTitle",
      value: function getTitle() {
        var title = this._element.getAttribute('data-bs-original-title') || this._config.title;
  
        return this._resolvePossibleFunction(title);
      }
    }, {
      key: "updateAttachment",
      value: function updateAttachment(attachment) {
        if (attachment === 'right') {
          return 'end';
        }
  
        if (attachment === 'left') {
          return 'start';
        }
  
        return attachment;
      } // Private
  
    }, {
      key: "_initializeOnDelegatedTarget",
      value: function _initializeOnDelegatedTarget(event, context) {
        return context || this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
      }
    }, {
      key: "_getOffset",
      value: function _getOffset() {
        var _this37 = this;
  
        var offset = this._config.offset;
  
        if (typeof offset === 'string') {
          return offset.split(',').map(function (val) {
            return Number.parseInt(val, 10);
          });
        }
  
        if (typeof offset === 'function') {
          return function (popperData) {
            return offset(popperData, _this37._element);
          };
        }
  
        return offset;
      }
    }, {
      key: "_resolvePossibleFunction",
      value: function _resolvePossibleFunction(content) {
        return typeof content === 'function' ? content.call(this._element) : content;
      }
    }, {
      key: "_getPopperConfig",
      value: function _getPopperConfig(attachment) {
        var _this38 = this;
  
        var defaultBsPopperConfig = {
          placement: attachment,
          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: ".".concat(this.constructor.NAME, "-arrow")
            }
          }, {
            name: 'onChange',
            enabled: true,
            phase: 'afterWrite',
            fn: function fn(data) {
              return _this38._handlePopperPlacementChange(data);
            }
          }],
          onFirstUpdate: function onFirstUpdate(data) {
            if (data.options.placement !== data.placement) {
              _this38._handlePopperPlacementChange(data);
            }
          }
        };
        return _objectSpread(_objectSpread({}, defaultBsPopperConfig), typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig);
      }
    }, {
      key: "_addAttachmentClass",
      value: function _addAttachmentClass(attachment) {
        this.getTipElement().classList.add("".concat(this._getBasicClassPrefix(), "-").concat(this.updateAttachment(attachment)));
      }
    }, {
      key: "_getAttachment",
      value: function _getAttachment(placement) {
        return AttachmentMap[placement.toUpperCase()];
      }
    }, {
      key: "_setListeners",
      value: function _setListeners() {
        var _this39 = this;
  
        var triggers = this._config.trigger.split(' ');
  
        triggers.forEach(function (trigger) {
          if (trigger === 'click') {
            EventHandler.on(_this39._element, _this39.constructor.Event.CLICK, _this39._config.selector, function (event) {
              return _this39.toggle(event);
            });
          } else if (trigger !== TRIGGER_MANUAL) {
            var eventIn = trigger === TRIGGER_HOVER ? _this39.constructor.Event.MOUSEENTER : _this39.constructor.Event.FOCUSIN;
            var eventOut = trigger === TRIGGER_HOVER ? _this39.constructor.Event.MOUSELEAVE : _this39.constructor.Event.FOCUSOUT;
            EventHandler.on(_this39._element, eventIn, _this39._config.selector, function (event) {
              return _this39._enter(event);
            });
            EventHandler.on(_this39._element, eventOut, _this39._config.selector, function (event) {
              return _this39._leave(event);
            });
          }
        });
  
        this._hideModalHandler = function () {
          if (_this39._element) {
            _this39.hide();
          }
        };
  
        EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
  
        if (this._config.selector) {
          this._config = _objectSpread(_objectSpread({}, this._config), {}, {
            trigger: 'manual',
            selector: ''
          });
        } else {
          this._fixTitle();
        }
      }
    }, {
      key: "_fixTitle",
      value: 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', '');
        }
      }
    }, {
      key: "_enter",
      value: function _enter(event, context) {
        context = this._initializeOnDelegatedTarget(event, context);
  
        if (event) {
          context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
        }
  
        if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$2) || 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);
      }
    }, {
      key: "_leave",
      value: function _leave(event, context) {
        context = this._initializeOnDelegatedTarget(event, context);
  
        if (event) {
          context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
        }
  
        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);
      }
    }, {
      key: "_isWithActiveTrigger",
      value: function _isWithActiveTrigger() {
        for (var trigger in this._activeTrigger) {
          if (this._activeTrigger[trigger]) {
            return true;
          }
        }
  
        return false;
      }
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        var dataAttributes = Manipulator.getDataAttributes(this._element);
        Object.keys(dataAttributes).forEach(function (dataAttr) {
          if (DISALLOWED_ATTRIBUTES.has(dataAttr)) {
            delete dataAttributes[dataAttr];
          }
        });
        config = _objectSpread(_objectSpread(_objectSpread({}, this.constructor.Default), dataAttributes), _typeof(config) === 'object' && config ? config : {});
        config.container = config.container === false ? document.body : getElement(config.container);
  
        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$4, config, this.constructor.DefaultType);
  
        if (config.sanitize) {
          config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn);
        }
  
        return config;
      }
    }, {
      key: "_getDelegateConfig",
      value: function _getDelegateConfig() {
        var config = {};
  
        for (var key in this._config) {
          if (this.constructor.Default[key] !== this._config[key]) {
            config[key] = this._config[key];
          }
        } // In the future can be replaced with:
        // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
        // `Object.fromEntries(keysWithDifferentValues)`
  
  
        return config;
      }
    }, {
      key: "_cleanTipClass",
      value: function _cleanTipClass() {
        var tip = this.getTipElement();
        var basicClassPrefixRegex = new RegExp("(^|\\s)".concat(this._getBasicClassPrefix(), "\\S+"), 'g');
        var tabClass = tip.getAttribute('class').match(basicClassPrefixRegex);
  
        if (tabClass !== null && tabClass.length > 0) {
          tabClass.map(function (token) {
            return token.trim();
          }).forEach(function (tClass) {
            return tip.classList.remove(tClass);
          });
        }
      }
    }, {
      key: "_getBasicClassPrefix",
      value: function _getBasicClassPrefix() {
        return CLASS_PREFIX$1;
      }
    }, {
      key: "_handlePopperPlacementChange",
      value: function _handlePopperPlacementChange(popperData) {
        var state = popperData.state;
  
        if (!state) {
          return;
        }
  
        this.tip = state.elements.popper;
  
        this._cleanTipClass();
  
        this._addAttachmentClass(this._getAttachment(state.placement));
      }
    }, {
      key: "_disposePopper",
      value: function _disposePopper() {
        if (this._popper) {
          this._popper.destroy();
  
          this._popper = null;
        }
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$3;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$4;
      }
    }, {
      key: "Event",
      get: function get() {
        return Event$2;
      }
    }, {
      key: "DefaultType",
      get: function get() {
        return DefaultType$3;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Tooltip.getOrCreateInstance(this, config);
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError("No method named \"".concat(config, "\""));
            }
  
            data[config]();
          }
        });
      }
    }]);
  
    return Tooltip;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Tooltip to jQuery only if jQuery is present
   */
  
  
  defineJQueryPlugin(Tooltip);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): popover.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$3 = 'popover';
  var DATA_KEY$3 = 'bs.popover';
  var EVENT_KEY$3 = ".".concat(DATA_KEY$3);
  var CLASS_PREFIX = 'bs-popover';
  
  var Default$2 = _objectSpread(_objectSpread({}, Tooltip.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>'
  });
  
  var DefaultType$2 = _objectSpread(_objectSpread({}, Tooltip.DefaultType), {}, {
    content: '(string|element|function)'
  });
  
  var Event$1 = {
    HIDE: "hide".concat(EVENT_KEY$3),
    HIDDEN: "hidden".concat(EVENT_KEY$3),
    SHOW: "show".concat(EVENT_KEY$3),
    SHOWN: "shown".concat(EVENT_KEY$3),
    INSERTED: "inserted".concat(EVENT_KEY$3),
    CLICK: "click".concat(EVENT_KEY$3),
    FOCUSIN: "focusin".concat(EVENT_KEY$3),
    FOCUSOUT: "focusout".concat(EVENT_KEY$3),
    MOUSEENTER: "mouseenter".concat(EVENT_KEY$3),
    MOUSELEAVE: "mouseleave".concat(EVENT_KEY$3)
  };
  var SELECTOR_TITLE = '.popover-header';
  var SELECTOR_CONTENT = '.popover-body';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Popover = /*#__PURE__*/function (_Tooltip) {
    _inherits(Popover, _Tooltip);
  
    var _super9 = _createSuper(Popover);
  
    function Popover() {
      _classCallCheck(this, Popover);
  
      return _super9.apply(this, arguments);
    }
  
    _createClass(Popover, [{
      key: "isWithContent",
      value: // Overrides
      function isWithContent() {
        return this.getTitle() || this._getContent();
      }
    }, {
      key: "setContent",
      value: function setContent(tip) {
        this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE);
  
        this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT);
      } // Private
  
    }, {
      key: "_getContent",
      value: function _getContent() {
        return this._resolvePossibleFunction(this._config.content);
      }
    }, {
      key: "_getBasicClassPrefix",
      value: function _getBasicClassPrefix() {
        return CLASS_PREFIX;
      } // Static
  
    }], [{
      key: "Default",
      get: // Getters
      function get() {
        return Default$2;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$3;
      }
    }, {
      key: "Event",
      get: function get() {
        return Event$1;
      }
    }, {
      key: "DefaultType",
      get: function get() {
        return DefaultType$2;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Popover.getOrCreateInstance(this, config);
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError("No method named \"".concat(config, "\""));
            }
  
            data[config]();
          }
        });
      }
    }]);
  
    return Popover;
  }(Tooltip);
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Popover to jQuery only if jQuery is present
   */
  
  
  defineJQueryPlugin(Popover);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): scrollspy.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$2 = 'scrollspy';
  var DATA_KEY$2 = 'bs.scrollspy';
  var EVENT_KEY$2 = ".".concat(DATA_KEY$2);
  var DATA_API_KEY$1 = '.data-api';
  var Default$1 = {
    offset: 10,
    method: 'auto',
    target: ''
  };
  var DefaultType$1 = {
    offset: 'number',
    method: 'string',
    target: '(string|element)'
  };
  var EVENT_ACTIVATE = "activate".concat(EVENT_KEY$2);
  var EVENT_SCROLL = "scroll".concat(EVENT_KEY$2);
  var EVENT_LOAD_DATA_API = "load".concat(EVENT_KEY$2).concat(DATA_API_KEY$1);
  var CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
  var CLASS_NAME_ACTIVE$1 = 'active';
  var SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
  var SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group';
  var SELECTOR_NAV_LINKS = '.nav-link';
  var SELECTOR_NAV_ITEMS = '.nav-item';
  var SELECTOR_LIST_ITEMS = '.list-group-item';
  var SELECTOR_LINK_ITEMS = "".concat(SELECTOR_NAV_LINKS, ", ").concat(SELECTOR_LIST_ITEMS, ", .").concat(CLASS_NAME_DROPDOWN_ITEM);
  var SELECTOR_DROPDOWN$1 = '.dropdown';
  var SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
  var METHOD_OFFSET = 'offset';
  var METHOD_POSITION = 'position';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var ScrollSpy = /*#__PURE__*/function (_BaseComponent9) {
    _inherits(ScrollSpy, _BaseComponent9);
  
    var _super10 = _createSuper(ScrollSpy);
  
    function ScrollSpy(element, config) {
      var _this40;
  
      _classCallCheck(this, ScrollSpy);
  
      _this40 = _super10.call(this, element);
      _this40._scrollElement = _this40._element.tagName === 'BODY' ? window : _this40._element;
      _this40._config = _this40._getConfig(config);
      _this40._offsets = [];
      _this40._targets = [];
      _this40._activeTarget = null;
      _this40._scrollHeight = 0;
      EventHandler.on(_this40._scrollElement, EVENT_SCROLL, function () {
        return _this40._process();
      });
  
      _this40.refresh();
  
      _this40._process();
  
      return _this40;
    } // Getters
  
  
    _createClass(ScrollSpy, [{
      key: "refresh",
      value: // Public
      function refresh() {
        var _this41 = this;
  
        var autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
        var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
        var offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
        this._offsets = [];
        this._targets = [];
        this._scrollHeight = this._getScrollHeight();
        var targets = SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target);
        targets.map(function (element) {
          var targetSelector = getSelectorFromElement(element);
          var target = targetSelector ? SelectorEngine.findOne(targetSelector) : null;
  
          if (target) {
            var targetBCR = target.getBoundingClientRect();
  
            if (targetBCR.width || targetBCR.height) {
              return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector];
            }
          }
  
          return null;
        }).filter(function (item) {
          return item;
        }).sort(function (a, b) {
          return a[0] - b[0];
        }).forEach(function (item) {
          _this41._offsets.push(item[0]);
  
          _this41._targets.push(item[1]);
        });
      }
    }, {
      key: "dispose",
      value: function dispose() {
        EventHandler.off(this._scrollElement, EVENT_KEY$2);
  
        _get(_getPrototypeOf(ScrollSpy.prototype), "dispose", this).call(this);
      } // Private
  
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default$1), Manipulator.getDataAttributes(this._element)), _typeof(config) === 'object' && config ? config : {});
        config.target = getElement(config.target) || document.documentElement;
        typeCheckConfig(NAME$2, config, DefaultType$1);
        return config;
      }
    }, {
      key: "_getScrollTop",
      value: function _getScrollTop() {
        return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
      }
    }, {
      key: "_getScrollHeight",
      value: function _getScrollHeight() {
        return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
      }
    }, {
      key: "_getOffsetHeight",
      value: function _getOffsetHeight() {
        return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
      }
    }, {
      key: "_process",
      value: function _process() {
        var scrollTop = this._getScrollTop() + this._config.offset;
  
        var scrollHeight = this._getScrollHeight();
  
        var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
  
        if (this._scrollHeight !== scrollHeight) {
          this.refresh();
        }
  
        if (scrollTop >= maxScroll) {
          var target = this._targets[this._targets.length - 1];
  
          if (this._activeTarget !== target) {
            this._activate(target);
          }
  
          return;
        }
  
        if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
          this._activeTarget = null;
  
          this._clear();
  
          return;
        }
  
        for (var i = this._offsets.length; i--;) {
          var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
  
          if (isActiveTarget) {
            this._activate(this._targets[i]);
          }
        }
      }
    }, {
      key: "_activate",
      value: function _activate(target) {
        this._activeTarget = target;
  
        this._clear();
  
        var queries = SELECTOR_LINK_ITEMS.split(',').map(function (selector) {
          return "".concat(selector, "[data-bs-target=\"").concat(target, "\"],").concat(selector, "[href=\"").concat(target, "\"]");
        });
        var link = SelectorEngine.findOne(queries.join(','), this._config.target);
        link.classList.add(CLASS_NAME_ACTIVE$1);
  
        if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
          SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, link.closest(SELECTOR_DROPDOWN$1)).classList.add(CLASS_NAME_ACTIVE$1);
        } else {
          SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP$1).forEach(function (listGroup) {
            // Set triggered links parents as active
            // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
            SelectorEngine.prev(listGroup, "".concat(SELECTOR_NAV_LINKS, ", ").concat(SELECTOR_LIST_ITEMS)).forEach(function (item) {
              return item.classList.add(CLASS_NAME_ACTIVE$1);
            }); // Handle special case when .nav-link is inside .nav-item
  
            SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(function (navItem) {
              SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach(function (item) {
                return item.classList.add(CLASS_NAME_ACTIVE$1);
              });
            });
          });
        }
  
        EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, {
          relatedTarget: target
        });
      }
    }, {
      key: "_clear",
      value: function _clear() {
        SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target).filter(function (node) {
          return node.classList.contains(CLASS_NAME_ACTIVE$1);
        }).forEach(function (node) {
          return node.classList.remove(CLASS_NAME_ACTIVE$1);
        });
      } // Static
  
    }], [{
      key: "Default",
      get: function get() {
        return Default$1;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME$2;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = ScrollSpy.getOrCreateInstance(this, config);
  
          if (typeof config !== 'string') {
            return;
          }
  
          if (typeof data[config] === 'undefined') {
            throw new TypeError("No method named \"".concat(config, "\""));
          }
  
          data[config]();
        });
      }
    }]);
  
    return ScrollSpy;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(window, EVENT_LOAD_DATA_API, function () {
    SelectorEngine.find(SELECTOR_DATA_SPY).forEach(function (spy) {
      return new ScrollSpy(spy);
    });
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .ScrollSpy to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(ScrollSpy);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): tab.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME$1 = 'tab';
  var DATA_KEY$1 = 'bs.tab';
  var EVENT_KEY$1 = ".".concat(DATA_KEY$1);
  var DATA_API_KEY = '.data-api';
  var EVENT_HIDE$1 = "hide".concat(EVENT_KEY$1);
  var EVENT_HIDDEN$1 = "hidden".concat(EVENT_KEY$1);
  var EVENT_SHOW$1 = "show".concat(EVENT_KEY$1);
  var EVENT_SHOWN$1 = "shown".concat(EVENT_KEY$1);
  var EVENT_CLICK_DATA_API = "click".concat(EVENT_KEY$1).concat(DATA_API_KEY);
  var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
  var CLASS_NAME_ACTIVE = 'active';
  var CLASS_NAME_FADE$1 = 'fade';
  var CLASS_NAME_SHOW$1 = 'show';
  var SELECTOR_DROPDOWN = '.dropdown';
  var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
  var SELECTOR_ACTIVE = '.active';
  var SELECTOR_ACTIVE_UL = ':scope > li > .active';
  var SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
  var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
  var SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Tab = /*#__PURE__*/function (_BaseComponent10) {
    _inherits(Tab, _BaseComponent10);
  
    var _super11 = _createSuper(Tab);
  
    function Tab() {
      _classCallCheck(this, Tab);
  
      return _super11.apply(this, arguments);
    }
  
    _createClass(Tab, [{
      key: "show",
      value: // Public
      function show() {
        var _this42 = this;
  
        if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) {
          return;
        }
  
        var previous;
        var target = getElementFromSelector(this._element);
  
        var listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);
  
        if (listElement) {
          var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE;
          previous = SelectorEngine.find(itemSelector, listElement);
          previous = previous[previous.length - 1];
        }
  
        var hideEvent = previous ? EventHandler.trigger(previous, EVENT_HIDE$1, {
          relatedTarget: this._element
        }) : null;
        var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, {
          relatedTarget: previous
        });
  
        if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) {
          return;
        }
  
        this._activate(this._element, listElement);
  
        var complete = function complete() {
          EventHandler.trigger(previous, EVENT_HIDDEN$1, {
            relatedTarget: _this42._element
          });
          EventHandler.trigger(_this42._element, EVENT_SHOWN$1, {
            relatedTarget: previous
          });
        };
  
        if (target) {
          this._activate(target, target.parentNode, complete);
        } else {
          complete();
        }
      } // Private
  
    }, {
      key: "_activate",
      value: function _activate(element, container, callback) {
        var _this43 = this;
  
        var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine.children(container, SELECTOR_ACTIVE);
        var active = activeElements[0];
        var isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE$1);
  
        var complete = function complete() {
          return _this43._transitionComplete(element, active, callback);
        };
  
        if (active && isTransitioning) {
          active.classList.remove(CLASS_NAME_SHOW$1);
  
          this._queueCallback(complete, element, true);
        } else {
          complete();
        }
      }
    }, {
      key: "_transitionComplete",
      value: function _transitionComplete(element, active, callback) {
        if (active) {
          active.classList.remove(CLASS_NAME_ACTIVE);
          var dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode);
  
          if (dropdownChild) {
            dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
          }
  
          if (active.getAttribute('role') === 'tab') {
            active.setAttribute('aria-selected', false);
          }
        }
  
        element.classList.add(CLASS_NAME_ACTIVE);
  
        if (element.getAttribute('role') === 'tab') {
          element.setAttribute('aria-selected', true);
        }
  
        reflow(element);
  
        if (element.classList.contains(CLASS_NAME_FADE$1)) {
          element.classList.add(CLASS_NAME_SHOW$1);
        }
  
        var parent = element.parentNode;
  
        if (parent && parent.nodeName === 'LI') {
          parent = parent.parentNode;
        }
  
        if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
          var dropdownElement = element.closest(SELECTOR_DROPDOWN);
  
          if (dropdownElement) {
            SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(function (dropdown) {
              return dropdown.classList.add(CLASS_NAME_ACTIVE);
            });
          }
  
          element.setAttribute('aria-expanded', true);
        }
  
        if (callback) {
          callback();
        }
      } // Static
  
    }], [{
      key: "NAME",
      get: // Getters
      function get() {
        return NAME$1;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Tab.getOrCreateInstance(this);
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError("No method named \"".concat(config, "\""));
            }
  
            data[config]();
          }
        });
      }
    }]);
  
    return Tab;
  }(BaseComponent);
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */
  
  
  EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
    if (['A', 'AREA'].includes(this.tagName)) {
      event.preventDefault();
    }
  
    if (isDisabled(this)) {
      return;
    }
  
    var data = Tab.getOrCreateInstance(this);
    data.show();
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Tab to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Tab);
  /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.1.3): toast.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */
  
  var NAME = 'toast';
  var DATA_KEY = 'bs.toast';
  var EVENT_KEY = ".".concat(DATA_KEY);
  var EVENT_MOUSEOVER = "mouseover".concat(EVENT_KEY);
  var EVENT_MOUSEOUT = "mouseout".concat(EVENT_KEY);
  var EVENT_FOCUSIN = "focusin".concat(EVENT_KEY);
  var EVENT_FOCUSOUT = "focusout".concat(EVENT_KEY);
  var EVENT_HIDE = "hide".concat(EVENT_KEY);
  var EVENT_HIDDEN = "hidden".concat(EVENT_KEY);
  var EVENT_SHOW = "show".concat(EVENT_KEY);
  var EVENT_SHOWN = "shown".concat(EVENT_KEY);
  var CLASS_NAME_FADE = 'fade';
  var CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
  
  var CLASS_NAME_SHOW = 'show';
  var CLASS_NAME_SHOWING = 'showing';
  var DefaultType = {
    animation: 'boolean',
    autohide: 'boolean',
    delay: 'number'
  };
  var Default = {
    animation: true,
    autohide: true,
    delay: 5000
  };
  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  
  var Toast = /*#__PURE__*/function (_BaseComponent11) {
    _inherits(Toast, _BaseComponent11);
  
    var _super12 = _createSuper(Toast);
  
    function Toast(element, config) {
      var _this44;
  
      _classCallCheck(this, Toast);
  
      _this44 = _super12.call(this, element);
      _this44._config = _this44._getConfig(config);
      _this44._timeout = null;
      _this44._hasMouseInteraction = false;
      _this44._hasKeyboardInteraction = false;
  
      _this44._setListeners();
  
      return _this44;
    } // Getters
  
  
    _createClass(Toast, [{
      key: "show",
      value: // Public
      function show() {
        var _this45 = this;
  
        var showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
  
        if (showEvent.defaultPrevented) {
          return;
        }
  
        this._clearTimeout();
  
        if (this._config.animation) {
          this._element.classList.add(CLASS_NAME_FADE);
        }
  
        var complete = function complete() {
          _this45._element.classList.remove(CLASS_NAME_SHOWING);
  
          EventHandler.trigger(_this45._element, EVENT_SHOWN);
  
          _this45._maybeScheduleHide();
        };
  
        this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
  
  
        reflow(this._element);
  
        this._element.classList.add(CLASS_NAME_SHOW);
  
        this._element.classList.add(CLASS_NAME_SHOWING);
  
        this._queueCallback(complete, this._element, this._config.animation);
      }
    }, {
      key: "hide",
      value: function hide() {
        var _this46 = this;
  
        if (!this._element.classList.contains(CLASS_NAME_SHOW)) {
          return;
        }
  
        var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
  
        if (hideEvent.defaultPrevented) {
          return;
        }
  
        var complete = function complete() {
          _this46._element.classList.add(CLASS_NAME_HIDE); // @deprecated
  
  
          _this46._element.classList.remove(CLASS_NAME_SHOWING);
  
          _this46._element.classList.remove(CLASS_NAME_SHOW);
  
          EventHandler.trigger(_this46._element, EVENT_HIDDEN);
        };
  
        this._element.classList.add(CLASS_NAME_SHOWING);
  
        this._queueCallback(complete, this._element, this._config.animation);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        this._clearTimeout();
  
        if (this._element.classList.contains(CLASS_NAME_SHOW)) {
          this._element.classList.remove(CLASS_NAME_SHOW);
        }
  
        _get(_getPrototypeOf(Toast.prototype), "dispose", this).call(this);
      } // Private
  
    }, {
      key: "_getConfig",
      value: function _getConfig(config) {
        config = _objectSpread(_objectSpread(_objectSpread({}, Default), Manipulator.getDataAttributes(this._element)), _typeof(config) === 'object' && config ? config : {});
        typeCheckConfig(NAME, config, this.constructor.DefaultType);
        return config;
      }
    }, {
      key: "_maybeScheduleHide",
      value: function _maybeScheduleHide() {
        var _this47 = this;
  
        if (!this._config.autohide) {
          return;
        }
  
        if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
          return;
        }
  
        this._timeout = setTimeout(function () {
          _this47.hide();
        }, this._config.delay);
      }
    }, {
      key: "_onInteraction",
      value: function _onInteraction(event, isInteracting) {
        switch (event.type) {
          case 'mouseover':
          case 'mouseout':
            this._hasMouseInteraction = isInteracting;
            break;
  
          case 'focusin':
          case 'focusout':
            this._hasKeyboardInteraction = isInteracting;
            break;
        }
  
        if (isInteracting) {
          this._clearTimeout();
  
          return;
        }
  
        var nextElement = event.relatedTarget;
  
        if (this._element === nextElement || this._element.contains(nextElement)) {
          return;
        }
  
        this._maybeScheduleHide();
      }
    }, {
      key: "_setListeners",
      value: function _setListeners() {
        var _this48 = this;
  
        EventHandler.on(this._element, EVENT_MOUSEOVER, function (event) {
          return _this48._onInteraction(event, true);
        });
        EventHandler.on(this._element, EVENT_MOUSEOUT, function (event) {
          return _this48._onInteraction(event, false);
        });
        EventHandler.on(this._element, EVENT_FOCUSIN, function (event) {
          return _this48._onInteraction(event, true);
        });
        EventHandler.on(this._element, EVENT_FOCUSOUT, function (event) {
          return _this48._onInteraction(event, false);
        });
      }
    }, {
      key: "_clearTimeout",
      value: function _clearTimeout() {
        clearTimeout(this._timeout);
        this._timeout = null;
      } // Static
  
    }], [{
      key: "DefaultType",
      get: function get() {
        return DefaultType;
      }
    }, {
      key: "Default",
      get: function get() {
        return Default;
      }
    }, {
      key: "NAME",
      get: function get() {
        return NAME;
      }
    }, {
      key: "jQueryInterface",
      value: function jQueryInterface(config) {
        return this.each(function () {
          var data = Toast.getOrCreateInstance(this, config);
  
          if (typeof config === 'string') {
            if (typeof data[config] === 'undefined') {
              throw new TypeError("No method named \"".concat(config, "\""));
            }
  
            data[config](this);
          }
        });
      }
    }]);
  
    return Toast;
  }(BaseComponent);
  
  enableDismissTrigger(Toast);
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Toast to jQuery only if jQuery is present
   */
  
  defineJQueryPlugin(Toast);
  
  
  /***/ }),
  
  /***/ "./node_modules/turbolinks/dist/turbolinks.js":
  /*!****************************************************!*\
    !*** ./node_modules/turbolinks/dist/turbolinks.js ***!
    \****************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
  
  /*
  Turbolinks 5.2.0
  Copyright © 2018 Basecamp, LLC
   */
  (function () {
    var t = this;
    (function () {
      (function () {
        this.Turbolinks = {
          supported: function () {
            return null != window.history.pushState && null != window.requestAnimationFrame && null != window.addEventListener;
          }(),
          visit: function visit(t, r) {
            return e.controller.visit(t, r);
          },
          clearCache: function clearCache() {
            return e.controller.clearCache();
          },
          setProgressBarDelay: function setProgressBarDelay(t) {
            return e.controller.setProgressBarDelay(t);
          }
        };
      }).call(this);
    }).call(t);
    var e = t.Turbolinks;
    (function () {
      (function () {
        var t,
            r,
            n,
            o = [].slice;
        e.copyObject = function (t) {
          var e, r, n;
          r = {};
  
          for (e in t) {
            n = t[e], r[e] = n;
          }
  
          return r;
        }, e.closest = function (e, r) {
          return t.call(e, r);
        }, t = function () {
          var t, e;
          return t = document.documentElement, null != (e = t.closest) ? e : function (t) {
            var e;
  
            for (e = this; e;) {
              if (e.nodeType === Node.ELEMENT_NODE && r.call(e, t)) return e;
              e = e.parentNode;
            }
          };
        }(), e.defer = function (t) {
          return setTimeout(t, 1);
        }, e.throttle = function (t) {
          var e;
          return e = null, function () {
            var r;
            return r = 1 <= arguments.length ? o.call(arguments, 0) : [], null != e ? e : e = requestAnimationFrame(function (n) {
              return function () {
                return e = null, t.apply(n, r);
              };
            }(this));
          };
        }, e.dispatch = function (t, e) {
          var r, o, i, s, a, u;
          return a = null != e ? e : {}, u = a.target, r = a.cancelable, o = a.data, i = document.createEvent("Events"), i.initEvent(t, !0, r === !0), i.data = null != o ? o : {}, i.cancelable && !n && (s = i.preventDefault, i.preventDefault = function () {
            return this.defaultPrevented || Object.defineProperty(this, "defaultPrevented", {
              get: function get() {
                return !0;
              }
            }), s.call(this);
          }), (null != u ? u : document).dispatchEvent(i), i;
        }, n = function () {
          var t;
          return t = document.createEvent("Events"), t.initEvent("test", !0, !0), t.preventDefault(), t.defaultPrevented;
        }(), e.match = function (t, e) {
          return r.call(t, e);
        }, r = function () {
          var t, e, r, n;
          return t = document.documentElement, null != (e = null != (r = null != (n = t.matchesSelector) ? n : t.webkitMatchesSelector) ? r : t.msMatchesSelector) ? e : t.mozMatchesSelector;
        }(), e.uuid = function () {
          var t, e, r;
  
          for (r = "", t = e = 1; 36 >= e; t = ++e) {
            r += 9 === t || 14 === t || 19 === t || 24 === t ? "-" : 15 === t ? "4" : 20 === t ? (Math.floor(4 * Math.random()) + 8).toString(16) : Math.floor(15 * Math.random()).toString(16);
          }
  
          return r;
        };
      }).call(this), function () {
        e.Location = function () {
          function t(t) {
            var e, r;
            null == t && (t = ""), r = document.createElement("a"), r.href = t.toString(), this.absoluteURL = r.href, e = r.hash.length, 2 > e ? this.requestURL = this.absoluteURL : (this.requestURL = this.absoluteURL.slice(0, -e), this.anchor = r.hash.slice(1));
          }
  
          var e, r, n, o;
          return t.wrap = function (t) {
            return t instanceof this ? t : new this(t);
          }, t.prototype.getOrigin = function () {
            return this.absoluteURL.split("/", 3).join("/");
          }, t.prototype.getPath = function () {
            var t, e;
            return null != (t = null != (e = this.requestURL.match(/\/\/[^\/]*(\/[^?;]*)/)) ? e[1] : void 0) ? t : "/";
          }, t.prototype.getPathComponents = function () {
            return this.getPath().split("/").slice(1);
          }, t.prototype.getLastPathComponent = function () {
            return this.getPathComponents().slice(-1)[0];
          }, t.prototype.getExtension = function () {
            var t, e;
            return null != (t = null != (e = this.getLastPathComponent().match(/\.[^.]*$/)) ? e[0] : void 0) ? t : "";
          }, t.prototype.isHTML = function () {
            return this.getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/);
          }, t.prototype.isPrefixedBy = function (t) {
            var e;
            return e = r(t), this.isEqualTo(t) || o(this.absoluteURL, e);
          }, t.prototype.isEqualTo = function (t) {
            return this.absoluteURL === (null != t ? t.absoluteURL : void 0);
          }, t.prototype.toCacheKey = function () {
            return this.requestURL;
          }, t.prototype.toJSON = function () {
            return this.absoluteURL;
          }, t.prototype.toString = function () {
            return this.absoluteURL;
          }, t.prototype.valueOf = function () {
            return this.absoluteURL;
          }, r = function r(t) {
            return e(t.getOrigin() + t.getPath());
          }, e = function e(t) {
            return n(t, "/") ? t : t + "/";
          }, o = function o(t, e) {
            return t.slice(0, e.length) === e;
          }, n = function n(t, e) {
            return t.slice(-e.length) === e;
          }, t;
        }();
      }.call(this), function () {
        var t = function t(_t, e) {
          return function () {
            return _t.apply(e, arguments);
          };
        };
  
        e.HttpRequest = function () {
          function r(r, n, o) {
            this.delegate = r, this.requestCanceled = t(this.requestCanceled, this), this.requestTimedOut = t(this.requestTimedOut, this), this.requestFailed = t(this.requestFailed, this), this.requestLoaded = t(this.requestLoaded, this), this.requestProgressed = t(this.requestProgressed, this), this.url = e.Location.wrap(n).requestURL, this.referrer = e.Location.wrap(o).absoluteURL, this.createXHR();
          }
  
          return r.NETWORK_FAILURE = 0, r.TIMEOUT_FAILURE = -1, r.timeout = 60, r.prototype.send = function () {
            var t;
            return this.xhr && !this.sent ? (this.notifyApplicationBeforeRequestStart(), this.setProgress(0), this.xhr.send(), this.sent = !0, "function" == typeof (t = this.delegate).requestStarted ? t.requestStarted() : void 0) : void 0;
          }, r.prototype.cancel = function () {
            return this.xhr && this.sent ? this.xhr.abort() : void 0;
          }, r.prototype.requestProgressed = function (t) {
            return t.lengthComputable ? this.setProgress(t.loaded / t.total) : void 0;
          }, r.prototype.requestLoaded = function () {
            return this.endRequest(function (t) {
              return function () {
                var e;
                return 200 <= (e = t.xhr.status) && 300 > e ? t.delegate.requestCompletedWithResponse(t.xhr.responseText, t.xhr.getResponseHeader("Turbolinks-Location")) : (t.failed = !0, t.delegate.requestFailedWithStatusCode(t.xhr.status, t.xhr.responseText));
              };
            }(this));
          }, r.prototype.requestFailed = function () {
            return this.endRequest(function (t) {
              return function () {
                return t.failed = !0, t.delegate.requestFailedWithStatusCode(t.constructor.NETWORK_FAILURE);
              };
            }(this));
          }, r.prototype.requestTimedOut = function () {
            return this.endRequest(function (t) {
              return function () {
                return t.failed = !0, t.delegate.requestFailedWithStatusCode(t.constructor.TIMEOUT_FAILURE);
              };
            }(this));
          }, r.prototype.requestCanceled = function () {
            return this.endRequest();
          }, r.prototype.notifyApplicationBeforeRequestStart = function () {
            return e.dispatch("turbolinks:request-start", {
              data: {
                url: this.url,
                xhr: this.xhr
              }
            });
          }, r.prototype.notifyApplicationAfterRequestEnd = function () {
            return e.dispatch("turbolinks:request-end", {
              data: {
                url: this.url,
                xhr: this.xhr
              }
            });
          }, r.prototype.createXHR = function () {
            return this.xhr = new XMLHttpRequest(), this.xhr.open("GET", this.url, !0), this.xhr.timeout = 1e3 * this.constructor.timeout, this.xhr.setRequestHeader("Accept", "text/html, application/xhtml+xml"), this.xhr.setRequestHeader("Turbolinks-Referrer", this.referrer), this.xhr.onprogress = this.requestProgressed, this.xhr.onload = this.requestLoaded, this.xhr.onerror = this.requestFailed, this.xhr.ontimeout = this.requestTimedOut, this.xhr.onabort = this.requestCanceled;
          }, r.prototype.endRequest = function (t) {
            return this.xhr ? (this.notifyApplicationAfterRequestEnd(), null != t && t.call(this), this.destroy()) : void 0;
          }, r.prototype.setProgress = function (t) {
            var e;
            return this.progress = t, "function" == typeof (e = this.delegate).requestProgressed ? e.requestProgressed(this.progress) : void 0;
          }, r.prototype.destroy = function () {
            var t;
            return this.setProgress(1), "function" == typeof (t = this.delegate).requestFinished && t.requestFinished(), this.delegate = null, this.xhr = null;
          }, r;
        }();
      }.call(this), function () {
        var t = function t(_t2, e) {
          return function () {
            return _t2.apply(e, arguments);
          };
        };
  
        e.ProgressBar = function () {
          function e() {
            this.trickle = t(this.trickle, this), this.stylesheetElement = this.createStylesheetElement(), this.progressElement = this.createProgressElement();
          }
  
          var r;
          return r = 300, e.defaultCSS = ".turbolinks-progress-bar {\n  position: fixed;\n  display: block;\n  top: 0;\n  left: 0;\n  height: 3px;\n  background: #0076ff;\n  z-index: 9999;\n  transition: width " + r + "ms ease-out, opacity " + r / 2 + "ms " + r / 2 + "ms ease-in;\n  transform: translate3d(0, 0, 0);\n}", e.prototype.show = function () {
            return this.visible ? void 0 : (this.visible = !0, this.installStylesheetElement(), this.installProgressElement(), this.startTrickling());
          }, e.prototype.hide = function () {
            return this.visible && !this.hiding ? (this.hiding = !0, this.fadeProgressElement(function (t) {
              return function () {
                return t.uninstallProgressElement(), t.stopTrickling(), t.visible = !1, t.hiding = !1;
              };
            }(this))) : void 0;
          }, e.prototype.setValue = function (t) {
            return this.value = t, this.refresh();
          }, e.prototype.installStylesheetElement = function () {
            return document.head.insertBefore(this.stylesheetElement, document.head.firstChild);
          }, e.prototype.installProgressElement = function () {
            return this.progressElement.style.width = 0, this.progressElement.style.opacity = 1, document.documentElement.insertBefore(this.progressElement, document.body), this.refresh();
          }, e.prototype.fadeProgressElement = function (t) {
            return this.progressElement.style.opacity = 0, setTimeout(t, 1.5 * r);
          }, e.prototype.uninstallProgressElement = function () {
            return this.progressElement.parentNode ? document.documentElement.removeChild(this.progressElement) : void 0;
          }, e.prototype.startTrickling = function () {
            return null != this.trickleInterval ? this.trickleInterval : this.trickleInterval = setInterval(this.trickle, r);
          }, e.prototype.stopTrickling = function () {
            return clearInterval(this.trickleInterval), this.trickleInterval = null;
          }, e.prototype.trickle = function () {
            return this.setValue(this.value + Math.random() / 100);
          }, e.prototype.refresh = function () {
            return requestAnimationFrame(function (t) {
              return function () {
                return t.progressElement.style.width = 10 + 90 * t.value + "%";
              };
            }(this));
          }, e.prototype.createStylesheetElement = function () {
            var t;
            return t = document.createElement("style"), t.type = "text/css", t.textContent = this.constructor.defaultCSS, t;
          }, e.prototype.createProgressElement = function () {
            var t;
            return t = document.createElement("div"), t.className = "turbolinks-progress-bar", t;
          }, e;
        }();
      }.call(this), function () {
        var t = function t(_t3, e) {
          return function () {
            return _t3.apply(e, arguments);
          };
        };
  
        e.BrowserAdapter = function () {
          function r(r) {
            this.controller = r, this.showProgressBar = t(this.showProgressBar, this), this.progressBar = new e.ProgressBar();
          }
  
          var n, o, i;
          return i = e.HttpRequest, n = i.NETWORK_FAILURE, o = i.TIMEOUT_FAILURE, r.prototype.visitProposedToLocationWithAction = function (t, e) {
            return this.controller.startVisitToLocationWithAction(t, e);
          }, r.prototype.visitStarted = function (t) {
            return t.issueRequest(), t.changeHistory(), t.loadCachedSnapshot();
          }, r.prototype.visitRequestStarted = function (t) {
            return this.progressBar.setValue(0), t.hasCachedSnapshot() || "restore" !== t.action ? this.showProgressBarAfterDelay() : this.showProgressBar();
          }, r.prototype.visitRequestProgressed = function (t) {
            return this.progressBar.setValue(t.progress);
          }, r.prototype.visitRequestCompleted = function (t) {
            return t.loadResponse();
          }, r.prototype.visitRequestFailedWithStatusCode = function (t, e) {
            switch (e) {
              case n:
              case o:
                return this.reload();
  
              default:
                return t.loadResponse();
            }
          }, r.prototype.visitRequestFinished = function (t) {
            return this.hideProgressBar();
          }, r.prototype.visitCompleted = function (t) {
            return t.followRedirect();
          }, r.prototype.pageInvalidated = function () {
            return this.reload();
          }, r.prototype.showProgressBarAfterDelay = function () {
            return this.progressBarTimeout = setTimeout(this.showProgressBar, this.controller.progressBarDelay);
          }, r.prototype.showProgressBar = function () {
            return this.progressBar.show();
          }, r.prototype.hideProgressBar = function () {
            return this.progressBar.hide(), clearTimeout(this.progressBarTimeout);
          }, r.prototype.reload = function () {
            return window.location.reload();
          }, r;
        }();
      }.call(this), function () {
        var t = function t(_t4, e) {
          return function () {
            return _t4.apply(e, arguments);
          };
        };
  
        e.History = function () {
          function r(e) {
            this.delegate = e, this.onPageLoad = t(this.onPageLoad, this), this.onPopState = t(this.onPopState, this);
          }
  
          return r.prototype.start = function () {
            return this.started ? void 0 : (addEventListener("popstate", this.onPopState, !1), addEventListener("load", this.onPageLoad, !1), this.started = !0);
          }, r.prototype.stop = function () {
            return this.started ? (removeEventListener("popstate", this.onPopState, !1), removeEventListener("load", this.onPageLoad, !1), this.started = !1) : void 0;
          }, r.prototype.push = function (t, r) {
            return t = e.Location.wrap(t), this.update("push", t, r);
          }, r.prototype.replace = function (t, r) {
            return t = e.Location.wrap(t), this.update("replace", t, r);
          }, r.prototype.onPopState = function (t) {
            var r, n, o, i;
            return this.shouldHandlePopState() && (i = null != (n = t.state) ? n.turbolinks : void 0) ? (r = e.Location.wrap(window.location), o = i.restorationIdentifier, this.delegate.historyPoppedToLocationWithRestorationIdentifier(r, o)) : void 0;
          }, r.prototype.onPageLoad = function (t) {
            return e.defer(function (t) {
              return function () {
                return t.pageLoaded = !0;
              };
            }(this));
          }, r.prototype.shouldHandlePopState = function () {
            return this.pageIsLoaded();
          }, r.prototype.pageIsLoaded = function () {
            return this.pageLoaded || "complete" === document.readyState;
          }, r.prototype.update = function (t, e, r) {
            var n;
            return n = {
              turbolinks: {
                restorationIdentifier: r
              }
            }, history[t + "State"](n, null, e);
          }, r;
        }();
      }.call(this), function () {
        e.HeadDetails = function () {
          function t(t) {
            var e, r, n, s, a, u;
  
            for (this.elements = {}, n = 0, a = t.length; a > n; n++) {
              u = t[n], u.nodeType === Node.ELEMENT_NODE && (s = u.outerHTML, r = null != (e = this.elements)[s] ? e[s] : e[s] = {
                type: i(u),
                tracked: o(u),
                elements: []
              }, r.elements.push(u));
            }
          }
  
          var e, r, n, o, i;
          return t.fromHeadElement = function (t) {
            var e;
            return new this(null != (e = null != t ? t.childNodes : void 0) ? e : []);
          }, t.prototype.hasElementWithKey = function (t) {
            return t in this.elements;
          }, t.prototype.getTrackedElementSignature = function () {
            var t, e;
            return function () {
              var r, n;
              r = this.elements, n = [];
  
              for (t in r) {
                e = r[t].tracked, e && n.push(t);
              }
  
              return n;
            }.call(this).join("");
          }, t.prototype.getScriptElementsNotInDetails = function (t) {
            return this.getElementsMatchingTypeNotInDetails("script", t);
          }, t.prototype.getStylesheetElementsNotInDetails = function (t) {
            return this.getElementsMatchingTypeNotInDetails("stylesheet", t);
          }, t.prototype.getElementsMatchingTypeNotInDetails = function (t, e) {
            var r, n, o, i, s, a;
            o = this.elements, s = [];
  
            for (n in o) {
              i = o[n], a = i.type, r = i.elements, a !== t || e.hasElementWithKey(n) || s.push(r[0]);
            }
  
            return s;
          }, t.prototype.getProvisionalElements = function () {
            var t, e, r, n, o, i, s;
            r = [], n = this.elements;
  
            for (e in n) {
              o = n[e], s = o.type, i = o.tracked, t = o.elements, null != s || i ? t.length > 1 && r.push.apply(r, t.slice(1)) : r.push.apply(r, t);
            }
  
            return r;
          }, t.prototype.getMetaValue = function (t) {
            var e;
            return null != (e = this.findMetaElementByName(t)) ? e.getAttribute("content") : void 0;
          }, t.prototype.findMetaElementByName = function (t) {
            var r, n, o, i;
            r = void 0, i = this.elements;
  
            for (o in i) {
              n = i[o].elements, e(n[0], t) && (r = n[0]);
            }
  
            return r;
          }, i = function i(t) {
            return r(t) ? "script" : n(t) ? "stylesheet" : void 0;
          }, o = function o(t) {
            return "reload" === t.getAttribute("data-turbolinks-track");
          }, r = function r(t) {
            var e;
            return e = t.tagName.toLowerCase(), "script" === e;
          }, n = function n(t) {
            var e;
            return e = t.tagName.toLowerCase(), "style" === e || "link" === e && "stylesheet" === t.getAttribute("rel");
          }, e = function e(t, _e) {
            var r;
            return r = t.tagName.toLowerCase(), "meta" === r && t.getAttribute("name") === _e;
          }, t;
        }();
      }.call(this), function () {
        e.Snapshot = function () {
          function t(t, e) {
            this.headDetails = t, this.bodyElement = e;
          }
  
          return t.wrap = function (t) {
            return t instanceof this ? t : "string" == typeof t ? this.fromHTMLString(t) : this.fromHTMLElement(t);
          }, t.fromHTMLString = function (t) {
            var e;
            return e = document.createElement("html"), e.innerHTML = t, this.fromHTMLElement(e);
          }, t.fromHTMLElement = function (t) {
            var r, n, o, i;
            return o = t.querySelector("head"), r = null != (i = t.querySelector("body")) ? i : document.createElement("body"), n = e.HeadDetails.fromHeadElement(o), new this(n, r);
          }, t.prototype.clone = function () {
            return new this.constructor(this.headDetails, this.bodyElement.cloneNode(!0));
          }, t.prototype.getRootLocation = function () {
            var t, r;
            return r = null != (t = this.getSetting("root")) ? t : "/", new e.Location(r);
          }, t.prototype.getCacheControlValue = function () {
            return this.getSetting("cache-control");
          }, t.prototype.getElementForAnchor = function (t) {
            try {
              return this.bodyElement.querySelector("[id='" + t + "'], a[name='" + t + "']");
            } catch (e) {}
          }, t.prototype.getPermanentElements = function () {
            return this.bodyElement.querySelectorAll("[id][data-turbolinks-permanent]");
          }, t.prototype.getPermanentElementById = function (t) {
            return this.bodyElement.querySelector("#" + t + "[data-turbolinks-permanent]");
          }, t.prototype.getPermanentElementsPresentInSnapshot = function (t) {
            var e, r, n, o, i;
  
            for (o = this.getPermanentElements(), i = [], r = 0, n = o.length; n > r; r++) {
              e = o[r], t.getPermanentElementById(e.id) && i.push(e);
            }
  
            return i;
          }, t.prototype.findFirstAutofocusableElement = function () {
            return this.bodyElement.querySelector("[autofocus]");
          }, t.prototype.hasAnchor = function (t) {
            return null != this.getElementForAnchor(t);
          }, t.prototype.isPreviewable = function () {
            return "no-preview" !== this.getCacheControlValue();
          }, t.prototype.isCacheable = function () {
            return "no-cache" !== this.getCacheControlValue();
          }, t.prototype.isVisitable = function () {
            return "reload" !== this.getSetting("visit-control");
          }, t.prototype.getSetting = function (t) {
            return this.headDetails.getMetaValue("turbolinks-" + t);
          }, t;
        }();
      }.call(this), function () {
        var t = [].slice;
  
        e.Renderer = function () {
          function e() {}
  
          var r;
          return e.render = function () {
            var e, r, n, o;
            return n = arguments[0], r = arguments[1], e = 3 <= arguments.length ? t.call(arguments, 2) : [], o = function (t, e, r) {
              r.prototype = t.prototype;
              var n = new r(),
                  o = t.apply(n, e);
              return Object(o) === o ? o : n;
            }(this, e, function () {}), o.delegate = n, o.render(r), o;
          }, e.prototype.renderView = function (t) {
            return this.delegate.viewWillRender(this.newBody), t(), this.delegate.viewRendered(this.newBody);
          }, e.prototype.invalidateView = function () {
            return this.delegate.viewInvalidated();
          }, e.prototype.createScriptElement = function (t) {
            var e;
            return "false" === t.getAttribute("data-turbolinks-eval") ? t : (e = document.createElement("script"), e.textContent = t.textContent, e.async = !1, r(e, t), e);
          }, r = function r(t, e) {
            var r, n, o, i, s, a, u;
  
            for (i = e.attributes, a = [], r = 0, n = i.length; n > r; r++) {
              s = i[r], o = s.name, u = s.value, a.push(t.setAttribute(o, u));
            }
  
            return a;
          }, e;
        }();
      }.call(this), function () {
        var t,
            r,
            n = function n(t, e) {
          function r() {
            this.constructor = t;
          }
  
          for (var n in e) {
            o.call(e, n) && (t[n] = e[n]);
          }
  
          return r.prototype = e.prototype, t.prototype = new r(), t.__super__ = e.prototype, t;
        },
            o = {}.hasOwnProperty;
  
        e.SnapshotRenderer = function (e) {
          function o(t, e, r) {
            this.currentSnapshot = t, this.newSnapshot = e, this.isPreview = r, this.currentHeadDetails = this.currentSnapshot.headDetails, this.newHeadDetails = this.newSnapshot.headDetails, this.currentBody = this.currentSnapshot.bodyElement, this.newBody = this.newSnapshot.bodyElement;
          }
  
          return n(o, e), o.prototype.render = function (t) {
            return this.shouldRender() ? (this.mergeHead(), this.renderView(function (e) {
              return function () {
                return e.replaceBody(), e.isPreview || e.focusFirstAutofocusableElement(), t();
              };
            }(this))) : this.invalidateView();
          }, o.prototype.mergeHead = function () {
            return this.copyNewHeadStylesheetElements(), this.copyNewHeadScriptElements(), this.removeCurrentHeadProvisionalElements(), this.copyNewHeadProvisionalElements();
          }, o.prototype.replaceBody = function () {
            var t;
            return t = this.relocateCurrentBodyPermanentElements(), this.activateNewBodyScriptElements(), this.assignNewBody(), this.replacePlaceholderElementsWithClonedPermanentElements(t);
          }, o.prototype.shouldRender = function () {
            return this.newSnapshot.isVisitable() && this.trackedElementsAreIdentical();
          }, o.prototype.trackedElementsAreIdentical = function () {
            return this.currentHeadDetails.getTrackedElementSignature() === this.newHeadDetails.getTrackedElementSignature();
          }, o.prototype.copyNewHeadStylesheetElements = function () {
            var t, e, r, n, o;
  
            for (n = this.getNewHeadStylesheetElements(), o = [], e = 0, r = n.length; r > e; e++) {
              t = n[e], o.push(document.head.appendChild(t));
            }
  
            return o;
          }, o.prototype.copyNewHeadScriptElements = function () {
            var t, e, r, n, o;
  
            for (n = this.getNewHeadScriptElements(), o = [], e = 0, r = n.length; r > e; e++) {
              t = n[e], o.push(document.head.appendChild(this.createScriptElement(t)));
            }
  
            return o;
          }, o.prototype.removeCurrentHeadProvisionalElements = function () {
            var t, e, r, n, o;
  
            for (n = this.getCurrentHeadProvisionalElements(), o = [], e = 0, r = n.length; r > e; e++) {
              t = n[e], o.push(document.head.removeChild(t));
            }
  
            return o;
          }, o.prototype.copyNewHeadProvisionalElements = function () {
            var t, e, r, n, o;
  
            for (n = this.getNewHeadProvisionalElements(), o = [], e = 0, r = n.length; r > e; e++) {
              t = n[e], o.push(document.head.appendChild(t));
            }
  
            return o;
          }, o.prototype.relocateCurrentBodyPermanentElements = function () {
            var e, n, o, i, s, a, u;
  
            for (a = this.getCurrentBodyPermanentElements(), u = [], e = 0, n = a.length; n > e; e++) {
              i = a[e], s = t(i), o = this.newSnapshot.getPermanentElementById(i.id), r(i, s.element), r(o, i), u.push(s);
            }
  
            return u;
          }, o.prototype.replacePlaceholderElementsWithClonedPermanentElements = function (t) {
            var e, n, o, i, s, a, u;
  
            for (u = [], o = 0, i = t.length; i > o; o++) {
              a = t[o], n = a.element, s = a.permanentElement, e = s.cloneNode(!0), u.push(r(n, e));
            }
  
            return u;
          }, o.prototype.activateNewBodyScriptElements = function () {
            var t, e, n, o, i, s;
  
            for (i = this.getNewBodyScriptElements(), s = [], e = 0, o = i.length; o > e; e++) {
              n = i[e], t = this.createScriptElement(n), s.push(r(n, t));
            }
  
            return s;
          }, o.prototype.assignNewBody = function () {
            return document.body = this.newBody;
          }, o.prototype.focusFirstAutofocusableElement = function () {
            var t;
            return null != (t = this.newSnapshot.findFirstAutofocusableElement()) ? t.focus() : void 0;
          }, o.prototype.getNewHeadStylesheetElements = function () {
            return this.newHeadDetails.getStylesheetElementsNotInDetails(this.currentHeadDetails);
          }, o.prototype.getNewHeadScriptElements = function () {
            return this.newHeadDetails.getScriptElementsNotInDetails(this.currentHeadDetails);
          }, o.prototype.getCurrentHeadProvisionalElements = function () {
            return this.currentHeadDetails.getProvisionalElements();
          }, o.prototype.getNewHeadProvisionalElements = function () {
            return this.newHeadDetails.getProvisionalElements();
          }, o.prototype.getCurrentBodyPermanentElements = function () {
            return this.currentSnapshot.getPermanentElementsPresentInSnapshot(this.newSnapshot);
          }, o.prototype.getNewBodyScriptElements = function () {
            return this.newBody.querySelectorAll("script");
          }, o;
        }(e.Renderer), t = function t(_t5) {
          var e;
          return e = document.createElement("meta"), e.setAttribute("name", "turbolinks-permanent-placeholder"), e.setAttribute("content", _t5.id), {
            element: e,
            permanentElement: _t5
          };
        }, r = function r(t, e) {
          var r;
          return (r = t.parentNode) ? r.replaceChild(e, t) : void 0;
        };
      }.call(this), function () {
        var t = function t(_t6, e) {
          function n() {
            this.constructor = _t6;
          }
  
          for (var o in e) {
            r.call(e, o) && (_t6[o] = e[o]);
          }
  
          return n.prototype = e.prototype, _t6.prototype = new n(), _t6.__super__ = e.prototype, _t6;
        },
            r = {}.hasOwnProperty;
  
        e.ErrorRenderer = function (e) {
          function r(t) {
            var e;
            e = document.createElement("html"), e.innerHTML = t, this.newHead = e.querySelector("head"), this.newBody = e.querySelector("body");
          }
  
          return t(r, e), r.prototype.render = function (t) {
            return this.renderView(function (e) {
              return function () {
                return e.replaceHeadAndBody(), e.activateBodyScriptElements(), t();
              };
            }(this));
          }, r.prototype.replaceHeadAndBody = function () {
            var t, e;
            return e = document.head, t = document.body, e.parentNode.replaceChild(this.newHead, e), t.parentNode.replaceChild(this.newBody, t);
          }, r.prototype.activateBodyScriptElements = function () {
            var t, e, r, n, o, i;
  
            for (n = this.getScriptElements(), i = [], e = 0, r = n.length; r > e; e++) {
              o = n[e], t = this.createScriptElement(o), i.push(o.parentNode.replaceChild(t, o));
            }
  
            return i;
          }, r.prototype.getScriptElements = function () {
            return document.documentElement.querySelectorAll("script");
          }, r;
        }(e.Renderer);
      }.call(this), function () {
        e.View = function () {
          function t(t) {
            this.delegate = t, this.htmlElement = document.documentElement;
          }
  
          return t.prototype.getRootLocation = function () {
            return this.getSnapshot().getRootLocation();
          }, t.prototype.getElementForAnchor = function (t) {
            return this.getSnapshot().getElementForAnchor(t);
          }, t.prototype.getSnapshot = function () {
            return e.Snapshot.fromHTMLElement(this.htmlElement);
          }, t.prototype.render = function (t, e) {
            var r, n, o;
            return o = t.snapshot, r = t.error, n = t.isPreview, this.markAsPreview(n), null != o ? this.renderSnapshot(o, n, e) : this.renderError(r, e);
          }, t.prototype.markAsPreview = function (t) {
            return t ? this.htmlElement.setAttribute("data-turbolinks-preview", "") : this.htmlElement.removeAttribute("data-turbolinks-preview");
          }, t.prototype.renderSnapshot = function (t, r, n) {
            return e.SnapshotRenderer.render(this.delegate, n, this.getSnapshot(), e.Snapshot.wrap(t), r);
          }, t.prototype.renderError = function (t, r) {
            return e.ErrorRenderer.render(this.delegate, r, t);
          }, t;
        }();
      }.call(this), function () {
        var t = function t(_t7, e) {
          return function () {
            return _t7.apply(e, arguments);
          };
        };
  
        e.ScrollManager = function () {
          function r(r) {
            this.delegate = r, this.onScroll = t(this.onScroll, this), this.onScroll = e.throttle(this.onScroll);
          }
  
          return r.prototype.start = function () {
            return this.started ? void 0 : (addEventListener("scroll", this.onScroll, !1), this.onScroll(), this.started = !0);
          }, r.prototype.stop = function () {
            return this.started ? (removeEventListener("scroll", this.onScroll, !1), this.started = !1) : void 0;
          }, r.prototype.scrollToElement = function (t) {
            return t.scrollIntoView();
          }, r.prototype.scrollToPosition = function (t) {
            var e, r;
            return e = t.x, r = t.y, window.scrollTo(e, r);
          }, r.prototype.onScroll = function (t) {
            return this.updatePosition({
              x: window.pageXOffset,
              y: window.pageYOffset
            });
          }, r.prototype.updatePosition = function (t) {
            var e;
            return this.position = t, null != (e = this.delegate) ? e.scrollPositionChanged(this.position) : void 0;
          }, r;
        }();
      }.call(this), function () {
        e.SnapshotCache = function () {
          function t(t) {
            this.size = t, this.keys = [], this.snapshots = {};
          }
  
          var r;
          return t.prototype.has = function (t) {
            var e;
            return e = r(t), e in this.snapshots;
          }, t.prototype.get = function (t) {
            var e;
            if (this.has(t)) return e = this.read(t), this.touch(t), e;
          }, t.prototype.put = function (t, e) {
            return this.write(t, e), this.touch(t), e;
          }, t.prototype.read = function (t) {
            var e;
            return e = r(t), this.snapshots[e];
          }, t.prototype.write = function (t, e) {
            var n;
            return n = r(t), this.snapshots[n] = e;
          }, t.prototype.touch = function (t) {
            var e, n;
            return n = r(t), e = this.keys.indexOf(n), e > -1 && this.keys.splice(e, 1), this.keys.unshift(n), this.trim();
          }, t.prototype.trim = function () {
            var t, e, r, n, o;
  
            for (n = this.keys.splice(this.size), o = [], t = 0, r = n.length; r > t; t++) {
              e = n[t], o.push(delete this.snapshots[e]);
            }
  
            return o;
          }, r = function r(t) {
            return e.Location.wrap(t).toCacheKey();
          }, t;
        }();
      }.call(this), function () {
        var t = function t(_t8, e) {
          return function () {
            return _t8.apply(e, arguments);
          };
        };
  
        e.Visit = function () {
          function r(r, n, o) {
            this.controller = r, this.action = o, this.performScroll = t(this.performScroll, this), this.identifier = e.uuid(), this.location = e.Location.wrap(n), this.adapter = this.controller.adapter, this.state = "initialized", this.timingMetrics = {};
          }
  
          var n;
          return r.prototype.start = function () {
            return "initialized" === this.state ? (this.recordTimingMetric("visitStart"), this.state = "started", this.adapter.visitStarted(this)) : void 0;
          }, r.prototype.cancel = function () {
            var t;
            return "started" === this.state ? (null != (t = this.request) && t.cancel(), this.cancelRender(), this.state = "canceled") : void 0;
          }, r.prototype.complete = function () {
            var t;
            return "started" === this.state ? (this.recordTimingMetric("visitEnd"), this.state = "completed", "function" == typeof (t = this.adapter).visitCompleted && t.visitCompleted(this), this.controller.visitCompleted(this)) : void 0;
          }, r.prototype.fail = function () {
            var t;
            return "started" === this.state ? (this.state = "failed", "function" == typeof (t = this.adapter).visitFailed ? t.visitFailed(this) : void 0) : void 0;
          }, r.prototype.changeHistory = function () {
            var t, e;
            return this.historyChanged ? void 0 : (t = this.location.isEqualTo(this.referrer) ? "replace" : this.action, e = n(t), this.controller[e](this.location, this.restorationIdentifier), this.historyChanged = !0);
          }, r.prototype.issueRequest = function () {
            return this.shouldIssueRequest() && null == this.request ? (this.progress = 0, this.request = new e.HttpRequest(this, this.location, this.referrer), this.request.send()) : void 0;
          }, r.prototype.getCachedSnapshot = function () {
            var t;
            return !(t = this.controller.getCachedSnapshotForLocation(this.location)) || null != this.location.anchor && !t.hasAnchor(this.location.anchor) || "restore" !== this.action && !t.isPreviewable() ? void 0 : t;
          }, r.prototype.hasCachedSnapshot = function () {
            return null != this.getCachedSnapshot();
          }, r.prototype.loadCachedSnapshot = function () {
            var t, e;
            return (e = this.getCachedSnapshot()) ? (t = this.shouldIssueRequest(), this.render(function () {
              var r;
              return this.cacheSnapshot(), this.controller.render({
                snapshot: e,
                isPreview: t
              }, this.performScroll), "function" == typeof (r = this.adapter).visitRendered && r.visitRendered(this), t ? void 0 : this.complete();
            })) : void 0;
          }, r.prototype.loadResponse = function () {
            return null != this.response ? this.render(function () {
              var t, e;
              return this.cacheSnapshot(), this.request.failed ? (this.controller.render({
                error: this.response
              }, this.performScroll), "function" == typeof (t = this.adapter).visitRendered && t.visitRendered(this), this.fail()) : (this.controller.render({
                snapshot: this.response
              }, this.performScroll), "function" == typeof (e = this.adapter).visitRendered && e.visitRendered(this), this.complete());
            }) : void 0;
          }, r.prototype.followRedirect = function () {
            return this.redirectedToLocation && !this.followedRedirect ? (this.location = this.redirectedToLocation, this.controller.replaceHistoryWithLocationAndRestorationIdentifier(this.redirectedToLocation, this.restorationIdentifier), this.followedRedirect = !0) : void 0;
          }, r.prototype.requestStarted = function () {
            var t;
            return this.recordTimingMetric("requestStart"), "function" == typeof (t = this.adapter).visitRequestStarted ? t.visitRequestStarted(this) : void 0;
          }, r.prototype.requestProgressed = function (t) {
            var e;
            return this.progress = t, "function" == typeof (e = this.adapter).visitRequestProgressed ? e.visitRequestProgressed(this) : void 0;
          }, r.prototype.requestCompletedWithResponse = function (t, r) {
            return this.response = t, null != r && (this.redirectedToLocation = e.Location.wrap(r)), this.adapter.visitRequestCompleted(this);
          }, r.prototype.requestFailedWithStatusCode = function (t, e) {
            return this.response = e, this.adapter.visitRequestFailedWithStatusCode(this, t);
          }, r.prototype.requestFinished = function () {
            var t;
            return this.recordTimingMetric("requestEnd"), "function" == typeof (t = this.adapter).visitRequestFinished ? t.visitRequestFinished(this) : void 0;
          }, r.prototype.performScroll = function () {
            return this.scrolled ? void 0 : ("restore" === this.action ? this.scrollToRestoredPosition() || this.scrollToTop() : this.scrollToAnchor() || this.scrollToTop(), this.scrolled = !0);
          }, r.prototype.scrollToRestoredPosition = function () {
            var t, e;
            return t = null != (e = this.restorationData) ? e.scrollPosition : void 0, null != t ? (this.controller.scrollToPosition(t), !0) : void 0;
          }, r.prototype.scrollToAnchor = function () {
            return null != this.location.anchor ? (this.controller.scrollToAnchor(this.location.anchor), !0) : void 0;
          }, r.prototype.scrollToTop = function () {
            return this.controller.scrollToPosition({
              x: 0,
              y: 0
            });
          }, r.prototype.recordTimingMetric = function (t) {
            var e;
            return null != (e = this.timingMetrics)[t] ? e[t] : e[t] = new Date().getTime();
          }, r.prototype.getTimingMetrics = function () {
            return e.copyObject(this.timingMetrics);
          }, n = function n(t) {
            switch (t) {
              case "replace":
                return "replaceHistoryWithLocationAndRestorationIdentifier";
  
              case "advance":
              case "restore":
                return "pushHistoryWithLocationAndRestorationIdentifier";
            }
          }, r.prototype.shouldIssueRequest = function () {
            return "restore" === this.action ? !this.hasCachedSnapshot() : !0;
          }, r.prototype.cacheSnapshot = function () {
            return this.snapshotCached ? void 0 : (this.controller.cacheSnapshot(), this.snapshotCached = !0);
          }, r.prototype.render = function (t) {
            return this.cancelRender(), this.frame = requestAnimationFrame(function (e) {
              return function () {
                return e.frame = null, t.call(e);
              };
            }(this));
          }, r.prototype.cancelRender = function () {
            return this.frame ? cancelAnimationFrame(this.frame) : void 0;
          }, r;
        }();
      }.call(this), function () {
        var t = function t(_t9, e) {
          return function () {
            return _t9.apply(e, arguments);
          };
        };
  
        e.Controller = function () {
          function r() {
            this.clickBubbled = t(this.clickBubbled, this), this.clickCaptured = t(this.clickCaptured, this), this.pageLoaded = t(this.pageLoaded, this), this.history = new e.History(this), this.view = new e.View(this), this.scrollManager = new e.ScrollManager(this), this.restorationData = {}, this.clearCache(), this.setProgressBarDelay(500);
          }
  
          return r.prototype.start = function () {
            return e.supported && !this.started ? (addEventListener("click", this.clickCaptured, !0), addEventListener("DOMContentLoaded", this.pageLoaded, !1), this.scrollManager.start(), this.startHistory(), this.started = !0, this.enabled = !0) : void 0;
          }, r.prototype.disable = function () {
            return this.enabled = !1;
          }, r.prototype.stop = function () {
            return this.started ? (removeEventListener("click", this.clickCaptured, !0), removeEventListener("DOMContentLoaded", this.pageLoaded, !1), this.scrollManager.stop(), this.stopHistory(), this.started = !1) : void 0;
          }, r.prototype.clearCache = function () {
            return this.cache = new e.SnapshotCache(10);
          }, r.prototype.visit = function (t, r) {
            var n, o;
            return null == r && (r = {}), t = e.Location.wrap(t), this.applicationAllowsVisitingLocation(t) ? this.locationIsVisitable(t) ? (n = null != (o = r.action) ? o : "advance", this.adapter.visitProposedToLocationWithAction(t, n)) : window.location = t : void 0;
          }, r.prototype.startVisitToLocationWithAction = function (t, r, n) {
            var o;
            return e.supported ? (o = this.getRestorationDataForIdentifier(n), this.startVisit(t, r, {
              restorationData: o
            })) : window.location = t;
          }, r.prototype.setProgressBarDelay = function (t) {
            return this.progressBarDelay = t;
          }, r.prototype.startHistory = function () {
            return this.location = e.Location.wrap(window.location), this.restorationIdentifier = e.uuid(), this.history.start(), this.history.replace(this.location, this.restorationIdentifier);
          }, r.prototype.stopHistory = function () {
            return this.history.stop();
          }, r.prototype.pushHistoryWithLocationAndRestorationIdentifier = function (t, r) {
            return this.restorationIdentifier = r, this.location = e.Location.wrap(t), this.history.push(this.location, this.restorationIdentifier);
          }, r.prototype.replaceHistoryWithLocationAndRestorationIdentifier = function (t, r) {
            return this.restorationIdentifier = r, this.location = e.Location.wrap(t), this.history.replace(this.location, this.restorationIdentifier);
          }, r.prototype.historyPoppedToLocationWithRestorationIdentifier = function (t, r) {
            var n;
            return this.restorationIdentifier = r, this.enabled ? (n = this.getRestorationDataForIdentifier(this.restorationIdentifier), this.startVisit(t, "restore", {
              restorationIdentifier: this.restorationIdentifier,
              restorationData: n,
              historyChanged: !0
            }), this.location = e.Location.wrap(t)) : this.adapter.pageInvalidated();
          }, r.prototype.getCachedSnapshotForLocation = function (t) {
            var e;
            return null != (e = this.cache.get(t)) ? e.clone() : void 0;
          }, r.prototype.shouldCacheSnapshot = function () {
            return this.view.getSnapshot().isCacheable();
          }, r.prototype.cacheSnapshot = function () {
            var t, r;
            return this.shouldCacheSnapshot() ? (this.notifyApplicationBeforeCachingSnapshot(), r = this.view.getSnapshot(), t = this.lastRenderedLocation, e.defer(function (e) {
              return function () {
                return e.cache.put(t, r.clone());
              };
            }(this))) : void 0;
          }, r.prototype.scrollToAnchor = function (t) {
            var e;
            return (e = this.view.getElementForAnchor(t)) ? this.scrollToElement(e) : this.scrollToPosition({
              x: 0,
              y: 0
            });
          }, r.prototype.scrollToElement = function (t) {
            return this.scrollManager.scrollToElement(t);
          }, r.prototype.scrollToPosition = function (t) {
            return this.scrollManager.scrollToPosition(t);
          }, r.prototype.scrollPositionChanged = function (t) {
            var e;
            return e = this.getCurrentRestorationData(), e.scrollPosition = t;
          }, r.prototype.render = function (t, e) {
            return this.view.render(t, e);
          }, r.prototype.viewInvalidated = function () {
            return this.adapter.pageInvalidated();
          }, r.prototype.viewWillRender = function (t) {
            return this.notifyApplicationBeforeRender(t);
          }, r.prototype.viewRendered = function () {
            return this.lastRenderedLocation = this.currentVisit.location, this.notifyApplicationAfterRender();
          }, r.prototype.pageLoaded = function () {
            return this.lastRenderedLocation = this.location, this.notifyApplicationAfterPageLoad();
          }, r.prototype.clickCaptured = function () {
            return removeEventListener("click", this.clickBubbled, !1), addEventListener("click", this.clickBubbled, !1);
          }, r.prototype.clickBubbled = function (t) {
            var e, r, n;
            return this.enabled && this.clickEventIsSignificant(t) && (r = this.getVisitableLinkForNode(t.target)) && (n = this.getVisitableLocationForLink(r)) && this.applicationAllowsFollowingLinkToLocation(r, n) ? (t.preventDefault(), e = this.getActionForLink(r), this.visit(n, {
              action: e
            })) : void 0;
          }, r.prototype.applicationAllowsFollowingLinkToLocation = function (t, e) {
            var r;
            return r = this.notifyApplicationAfterClickingLinkToLocation(t, e), !r.defaultPrevented;
          }, r.prototype.applicationAllowsVisitingLocation = function (t) {
            var e;
            return e = this.notifyApplicationBeforeVisitingLocation(t), !e.defaultPrevented;
          }, r.prototype.notifyApplicationAfterClickingLinkToLocation = function (t, r) {
            return e.dispatch("turbolinks:click", {
              target: t,
              data: {
                url: r.absoluteURL
              },
              cancelable: !0
            });
          }, r.prototype.notifyApplicationBeforeVisitingLocation = function (t) {
            return e.dispatch("turbolinks:before-visit", {
              data: {
                url: t.absoluteURL
              },
              cancelable: !0
            });
          }, r.prototype.notifyApplicationAfterVisitingLocation = function (t) {
            return e.dispatch("turbolinks:visit", {
              data: {
                url: t.absoluteURL
              }
            });
          }, r.prototype.notifyApplicationBeforeCachingSnapshot = function () {
            return e.dispatch("turbolinks:before-cache");
          }, r.prototype.notifyApplicationBeforeRender = function (t) {
            return e.dispatch("turbolinks:before-render", {
              data: {
                newBody: t
              }
            });
          }, r.prototype.notifyApplicationAfterRender = function () {
            return e.dispatch("turbolinks:render");
          }, r.prototype.notifyApplicationAfterPageLoad = function (t) {
            return null == t && (t = {}), e.dispatch("turbolinks:load", {
              data: {
                url: this.location.absoluteURL,
                timing: t
              }
            });
          }, r.prototype.startVisit = function (t, e, r) {
            var n;
            return null != (n = this.currentVisit) && n.cancel(), this.currentVisit = this.createVisit(t, e, r), this.currentVisit.start(), this.notifyApplicationAfterVisitingLocation(t);
          }, r.prototype.createVisit = function (t, r, n) {
            var o, i, s, a, u;
            return i = null != n ? n : {}, a = i.restorationIdentifier, s = i.restorationData, o = i.historyChanged, u = new e.Visit(this, t, r), u.restorationIdentifier = null != a ? a : e.uuid(), u.restorationData = e.copyObject(s), u.historyChanged = o, u.referrer = this.location, u;
          }, r.prototype.visitCompleted = function (t) {
            return this.notifyApplicationAfterPageLoad(t.getTimingMetrics());
          }, r.prototype.clickEventIsSignificant = function (t) {
            return !(t.defaultPrevented || t.target.isContentEditable || t.which > 1 || t.altKey || t.ctrlKey || t.metaKey || t.shiftKey);
          }, r.prototype.getVisitableLinkForNode = function (t) {
            return this.nodeIsVisitable(t) ? e.closest(t, "a[href]:not([target]):not([download])") : void 0;
          }, r.prototype.getVisitableLocationForLink = function (t) {
            var r;
            return r = new e.Location(t.getAttribute("href")), this.locationIsVisitable(r) ? r : void 0;
          }, r.prototype.getActionForLink = function (t) {
            var e;
            return null != (e = t.getAttribute("data-turbolinks-action")) ? e : "advance";
          }, r.prototype.nodeIsVisitable = function (t) {
            var r;
            return (r = e.closest(t, "[data-turbolinks]")) ? "false" !== r.getAttribute("data-turbolinks") : !0;
          }, r.prototype.locationIsVisitable = function (t) {
            return t.isPrefixedBy(this.view.getRootLocation()) && t.isHTML();
          }, r.prototype.getCurrentRestorationData = function () {
            return this.getRestorationDataForIdentifier(this.restorationIdentifier);
          }, r.prototype.getRestorationDataForIdentifier = function (t) {
            var e;
            return null != (e = this.restorationData)[t] ? e[t] : e[t] = {};
          }, r;
        }();
      }.call(this), function () {
        !function () {
          var t, e;
          if ((t = e = document.currentScript) && !e.hasAttribute("data-turbolinks-suppress-warning")) for (; t = t.parentNode;) {
            if (t === document.body) return console.warn("You are loading Turbolinks from a <script> element inside the <body> element. This is probably not what you meant to do!\n\nLoad your application\u2019s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.\n\nFor more information, see: https://github.com/turbolinks/turbolinks#working-with-script-elements\n\n\u2014\u2014\nSuppress this warning by adding a `data-turbolinks-suppress-warning` attribute to: %s", e.outerHTML);
          }
        }();
      }.call(this), function () {
        var t, r, n;
        e.start = function () {
          return r() ? (null == e.controller && (e.controller = t()), e.controller.start()) : void 0;
        }, r = function r() {
          return null == window.Turbolinks && (window.Turbolinks = e), n();
        }, t = function t() {
          var t;
          return t = new e.Controller(), t.adapter = new e.BrowserAdapter(t), t;
        }, n = function n() {
          return window.Turbolinks === e;
        }, n() && e.start();
      }.call(this);
    }).call(this), "object" == ( false ? undefined : _typeof(module)) && module.exports ? module.exports = e :  true && !(__WEBPACK_AMD_DEFINE_FACTORY__ = (e),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
  				__WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  }).call(this);
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module)))
  
  /***/ }),
  
  /***/ "./node_modules/webpack/buildin/module.js":
  /*!***********************************!*\
    !*** (webpack)/buildin/module.js ***!
    \***********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  module.exports = function (module) {
    if (!module.webpackPolyfill) {
      module.deprecate = function () {};
  
      module.paths = []; // module.parent = undefined by default
  
      if (!module.children) module.children = [];
      Object.defineProperty(module, "loaded", {
        enumerable: true,
        get: function get() {
          return module.l;
        }
      });
      Object.defineProperty(module, "id", {
        enumerable: true,
        get: function get() {
          return module.i;
        }
      });
      module.webpackPolyfill = 1;
    }
  
    return module;
  };
  
  /***/ })
  
  /******/ });
  //# sourceMappingURL=application-c0a7c57651bc860006bd.js.map