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