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