1var _____WB$wombat$assign$function_____=function(name){return (globalThis._wb_wombat && globalThis._wb_wombat.local_init && globalThis._wb_wombat.local_init(name))||globalThis[name];};if(!globalThis.__WB_pmw){globalThis.__WB_pmw=function(obj){this.__WB_source=obj;return this;}}{ 2let window = _____WB$wombat$assign$function_____("window"); 3let self = _____WB$wombat$assign$function_____("self"); 4let document = _____WB$wombat$assign$function_____("document"); 5let location = _____WB$wombat$assign$function_____("location"); 6let top = _____WB$wombat$assign$function_____("top"); 7let parent = _____WB$wombat$assign$function_____("parent"); 8let frames = _____WB$wombat$assign$function_____("frames"); 9let opener = _____WB$wombat$assign$function_____("opener"); 10/*! 11 * Bootstrap v4.3.1 (https://getbootstrap.com/) 12 * Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 13 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 14 */ 15(function (global, factory) { 16 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) : typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) : (global = global || self, factory(global.bootstrap = {}, global.jQuery)); 17})(this, function (exports, $) { 18 'use strict'; 19 20 $ = $ && $.hasOwnProperty('default') ? $['default'] : $; 21 22 function _defineProperties(target, props) { 23 for (var i = 0; i < props.length; i++) { 24 var descriptor = props[i]; 25 descriptor.enumerable = descriptor.enumerable || false; 26 descriptor.configurable = true; 27 if ("value" in descriptor) descriptor.writable = true; 28 Object.defineProperty(target, descriptor.key, descriptor); 29 } 30 } 31 32 function _createClass(Constructor, protoProps, staticProps) { 33 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 34 if (staticProps) _defineProperties(Constructor, staticProps); 35 return Constructor; 36 } 37 38 function _defineProperty(obj, key, value) { 39 if (key in obj) { 40 Object.defineProperty(obj, key, { 41 value: value, 42 enumerable: true, 43 configurable: true, 44 writable: true 45 }); 46 } else { 47 obj[key] = value; 48 } 49 50 return obj; 51 } 52 53 function _objectSpread(target) { 54 for (var i = 1; i < arguments.length; i++) { 55 var source = arguments[i] != null ? arguments[i] : {}; 56 var ownKeys = Object.keys(source); 57 58 if (typeof Object.getOwnPropertySymbols === 'function') { 59 ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { 60 return Object.getOwnPropertyDescriptor(source, sym).enumerable; 61 })); 62 } 63 64 ownKeys.forEach(function (key) { 65 _defineProperty(target, key, source[key]); 66 }); 67 } 68 69 return target; 70 } 71 72 function _inheritsLoose(subClass, superClass) { 73 subClass.prototype = Object.create(superClass.prototype); 74 subClass.prototype.constructor = subClass; 75 subClass.__proto__ = superClass; 76 } 77 /** 78 * -------------------------------------------------------------------------- 79 * Bootstrap (v4.3.1): util.js 80 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 81 * -------------------------------------------------------------------------- 82 */ 83 84 /** 85 * ------------------------------------------------------------------------ 86 * Private TransitionEnd Helpers 87 * ------------------------------------------------------------------------ 88 */ 89 90 91 var TRANSITION_END = 'transitionend'; 92 var MAX_UID = 1000000; 93 var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 94 95 function toType(obj) { 96 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 97 } 98 99 function getSpecialTransitionEndEvent() { 100 return { 101 bindType: TRANSITION_END, 102 delegateType: TRANSITION_END, 103 handle: function handle(event) { 104 if ($(event.target).is(this)) { 105 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params 106 } 107 108 return undefined; // eslint-disable-line no-undefined 109 } 110 }; 111 } 112 113 function transitionEndEmulator(duration) { 114 var _this = this; 115 116 var called = false;
117 $(this).one(Util.TRANSITION_END, function () { 118 called = true; 119 }); 120 setTimeout(function () { 121 if (!called) { 122 Util.triggerTransitionEnd(_this); 123 } 124 }, duration); 125 return this; 126 } 127 128 function setTransitionEndSupport() { 129 $.fn.emulateTransitionEnd = transitionEndEmulator; 130 $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); 131 } 132 /** 133 * -------------------------------------------------------------------------- 134 * Public Util Api 135 * -------------------------------------------------------------------------- 136 */ 137 138 139 var Util = { 140 TRANSITION_END: 'bsTransitionEnd', 141 getUID: function getUID(prefix) { 142 do { 143 // eslint-disable-next-line no-bitwise 144 prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here 145 } while (document.getElementById(prefix)); 146 147 return prefix; 148 }, 149 getSelectorFromElement: function getSelectorFromElement(element) { 150 var selector = element.getAttribute('data-target'); 151 152 if (!selector || selector === '#') { 153 var hrefAttr = element.getAttribute('href'); 154 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; 155 } 156 157 try { 158 return document.querySelector(selector) ? selector : null; 159 } catch (err) { 160 return null; 161 } 162 }, 163 getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { 164 if (!element) { 165 return 0; 166 } // Get transition-duration of the element 167 168 169 var transitionDuration = $(element).css('transition-duration'); 170 var transitionDelay = $(element).css('transition-delay'); 171 var floatTransitionDuration = parseFloat(transitionDuration); 172 var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 173 174 if (!floatTransitionDuration && !floatTransitionDelay) { 175 return 0; 176 } // If multiple durations are defined, take the first 177 178 179 transitionDuration = transitionDuration.split(',')[0]; 180 transitionDelay = transitionDelay.split(',')[0]; 181 return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 182 }, 183 reflow: function reflow(element) { 184 return element.offsetHeight; 185 }, 186 triggerTransitionEnd: function triggerTransitionEnd(element) { 187 $(element).trigger(TRANSITION_END); 188 }, 189 // TODO: Remove in v5 190 supportsTransitionEnd: function supportsTransitionEnd() { 191 return Boolean(TRANSITION_END); 192 }, 193 isElement: function isElement(obj) { 194 return (obj[0] || obj).nodeType; 195 }, 196 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { 197 for (var property in configTypes) { 198 if (Object.prototype.hasOwnProperty.call(configTypes, property)) { 199 var expectedTypes = configTypes[property]; 200 var value = config[property]; 201 var valueType = value && Util.isElement(value) ? 'element' : toType(value); 202 203 if (!new RegExp(expectedTypes).test(valueType)) { 204 throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\".")); 205 } 206 } 207 } 208 }, 209 findShadowRoot: function findShadowRoot(element) { 210 if (!document.documentElement.attachShadow) { 211 return null; 212 } // Can find the shadow root otherwise it'll return the document 213 214 215 if (typeof element.getRootNode === 'function') { 216 var root = element.getRootNode(); 217 return root instanceof ShadowRoot ? root : null; 218 } 219 220 if (element instanceof ShadowRoot) { 221 return element; 222 } // when we don't find a shadow root 223 224 225 if (!element.parentNode) { 226 return null; 227 } 228 229 return Util.findShadowRoot(element.parentNode); 230 } 231 }; 232 setTransitionEndSupport(); 233 /** 234 * ------------------------------------------------------------------------ 235 * Constants 236 * ------------------------------------------------------------------------ 237 */ 238 239 var NAME = 'alert'; 240 var VERSION = '4.3.1'; 241 var DATA_KEY = 'bs.alert'; 242 var EVENT_KEY = "." + DATA_KEY; 243 var DATA_API_KEY = '.data-api'; 244 var JQUERY_NO_CONFLICT = $.fn[NAME]; 245 var Selector = { 246 DISMISS: '[data-dismiss="alert"]' 247 }; 248 var Event = { 249 CLOSE: "close" + EVENT_KEY, 250 CLOSED: "closed" + EVENT_KEY, 251 CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY 252 }; 253 var ClassName = { 254 ALERT: 'alert', 255 FADE: 'fade', 256 SHOW: 'show' 257 /** 258 * ------------------------------------------------------------------------ 259 * Class Definition 260 * ------------------------------------------------------------------------ 261 */ 262 263 }; 264 265 var Alert = 266 /*#__PURE__*/ 267 function () { 268 function Alert(element) { 269 this._element = element; 270 } // Getters 271 272 273 var _proto = Alert.prototype; // Public 274 275 _proto.close = function close(element) { 276 var rootElement = this._element; 277 278 if (element) { 279 rootElement = this._getRootElement(element); 280 } 281 282 var customEvent = this._triggerCloseEvent(rootElement); 283 284 if (customEvent.isDefaultPrevented()) { 285 return; 286 } 287 288 this._removeElement(rootElement); 289 }; 290 291 _proto.dispose = function dispose() { 292 $.removeData(this._element, DATA_KEY); 293 this._element = null; 294 } // Private 295 ; 296 297 _proto._getRootElement = function _getRootElement(element) { 298 var selector = Util.getSelectorFromElement(element); 299 var parent = false;
300 301 if (selector) { 302 parent = document.querySelector(selector); 303 } 304 305 if (!parent) { 306 parent = $(element).closest("." + ClassName.ALERT)[0]; 307 } 308 309 return parent; 310 }; 311 312 _proto._triggerCloseEvent = function _triggerCloseEvent(element) { 313 var closeEvent = $.Event(Event.CLOSE); 314 $(element).trigger(closeEvent); 315 return closeEvent; 316 }; 317 318 _proto._removeElement = function _removeElement(element) { 319 var _this = this; 320 321 $(element).removeClass(ClassName.SHOW); 322 323 if (!$(element).hasClass(ClassName.FADE)) { 324 this._destroyElement(element); 325 326 return; 327 } 328 329 var transitionDuration = Util.getTransitionDurationFromElement(element); 330 $(element).one(Util.TRANSITION_END, function (event) { 331 return _this._destroyElement(element, event); 332 }).emulateTransitionEnd(transitionDuration); 333 }; 334 335 _proto._destroyElement = function _destroyElement(element) { 336 $(element).detach().trigger(Event.CLOSED).remove(); 337 } // Static 338 ; 339 340 Alert._jQueryInterface = function _jQueryInterface(config) { 341 return this.each(function () { 342 var $element = $(this); 343 var data = $element.data(DATA_KEY); 344 345 if (!data) { 346 data = new Alert(this); 347 $element.data(DATA_KEY, data); 348 } 349 350 if (config === 'close') { 351 data[config](this); 352 } 353 }); 354 }; 355 356 Alert._handleDismiss = function _handleDismiss(alertInstance) { 357 return function (event) { 358 if (event) { 359 event.preventDefault(); 360 } 361 362 alertInstance.close(this); 363 }; 364 }; 365 366 _createClass(Alert, null, [{ 367 key: "VERSION", 368 get: function get() { 369 return VERSION; 370 } 371 }]); 372 373 return Alert; 374 }(); 375 /** 376 * ------------------------------------------------------------------------ 377 * Data Api implementation 378 * ------------------------------------------------------------------------ 379 */ 380 381 382 $(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert())); 383 /** 384 * ------------------------------------------------------------------------ 385 * jQuery 386 * ------------------------------------------------------------------------ 387 */ 388 389 $.fn[NAME] = Alert._jQueryInterface; 390 $.fn[NAME].Constructor = Alert; 391 392 $.fn[NAME].noConflict = function () { 393 $.fn[NAME] = JQUERY_NO_CONFLICT; 394 return Alert._jQueryInterface; 395 }; 396 /** 397 * ------------------------------------------------------------------------ 398 * Constants 399 * ------------------------------------------------------------------------ 400 */ 401 402 403 var NAME$1 = 'button'; 404 var VERSION$1 = '4.3.1'; 405 var DATA_KEY$1 = 'bs.button'; 406 var EVENT_KEY$1 = "." + DATA_KEY$1; 407 var DATA_API_KEY$1 = '.data-api'; 408 var JQUERY_NO_CONFLICT$1 = $.fn[NAME$1]; 409 var ClassName$1 = { 410 ACTIVE: 'active', 411 BUTTON: 'btn', 412 FOCUS: 'focus' 413 }; 414 var Selector$1 = { 415 DATA_TOGGLE_CARROT: '[data-toggle^="button"]', 416 DATA_TOGGLE: '[data-toggle="buttons"]', 417 INPUT: 'input:not([type="hidden"])', 418 ACTIVE: '.active', 419 BUTTON: '.btn' 420 }; 421 var Event$1 = { 422 CLICK_DATA_API: "click" + EVENT_KEY$1 + DATA_API_KEY$1, 423 FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1) 424 /** 425 * ------------------------------------------------------------------------ 426 * Class Definition 427 * ------------------------------------------------------------------------ 428 */ 429 430 }; 431 432 var Button = 433 /*#__PURE__*/ 434 function () { 435 function Button(element) { 436 this._element = element; 437 } // Getters 438 439 440 var _proto = Button.prototype; // Public 441 442 _proto.toggle = function toggle() { 443 var triggerChangeEvent = true; 444 var addAriaPressed = true; 445 var rootElement = $(this._element).closest(Selector$1.DATA_TOGGLE)[0]; 446 447 if (rootElement) { 448 var input = this._element.querySelector(Selector$1.INPUT); 449 450 if (input) { 451 if (input.type === 'radio') { 452 if (input.checked && this._element.classList.contains(ClassName$1.ACTIVE)) { 453 triggerChangeEvent = false;
454 } else { 455 var activeElement = rootElement.querySelector(Selector$1.ACTIVE); 456 457 if (activeElement) { 458 $(activeElement).removeClass(ClassName$1.ACTIVE); 459 } 460 } 461 } 462 463 if (triggerChangeEvent) { 464 if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) { 465 return; 466 } 467 468 input.checked = !this._element.classList.contains(ClassName$1.ACTIVE); 469 $(input).trigger('change'); 470 } 471 472 input.focus(); 473 addAriaPressed = false; 474 } 475 } 476 477 if (addAriaPressed) { 478 this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName$1.ACTIVE)); 479 } 480 481 if (triggerChangeEvent) { 482 $(this._element).toggleClass(ClassName$1.ACTIVE); 483 } 484 }; 485 486 _proto.dispose = function dispose() { 487 $.removeData(this._element, DATA_KEY$1); 488 this._element = null; 489 } // Static 490 ; 491 492 Button._jQueryInterface = function _jQueryInterface(config) { 493 return this.each(function () { 494 var data = $(this).data(DATA_KEY$1); 495 496 if (!data) { 497 data = new Button(this); 498 $(this).data(DATA_KEY$1, data); 499 } 500 501 if (config === 'toggle') { 502 data[config](); 503 } 504 }); 505 }; 506 507 _createClass(Button, null, [{ 508 key: "VERSION", 509 get: function get() { 510 return VERSION$1; 511 } 512 }]); 513 514 return Button; 515 }(); 516 /** 517 * ------------------------------------------------------------------------ 518 * Data Api implementation 519 * ------------------------------------------------------------------------ 520 */ 521 522 523 $(document).on(Event$1.CLICK_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) { 524 event.preventDefault(); 525 var button = event.target; 526 527 if (!$(button).hasClass(ClassName$1.BUTTON)) { 528 button = $(button).closest(Selector$1.BUTTON); 529 } 530 531 Button._jQueryInterface.call($(button), 'toggle'); 532 }).on(Event$1.FOCUS_BLUR_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) { 533 var button = $(event.target).closest(Selector$1.BUTTON)[0]; 534 $(button).toggleClass(ClassName$1.FOCUS, /^focus(in)?$/.test(event.type)); 535 }); 536 /** 537 * ------------------------------------------------------------------------ 538 * jQuery 539 * ------------------------------------------------------------------------ 540 */ 541 542 $.fn[NAME$1] = Button._jQueryInterface; 543 $.fn[NAME$1].Constructor = Button; 544 545 $.fn[NAME$1].noConflict = function () { 546 $.fn[NAME$1] = JQUERY_NO_CONFLICT$1; 547 return Button._jQueryInterface; 548 }; 549 /** 550 * ------------------------------------------------------------------------ 551 * Constants 552 * ------------------------------------------------------------------------ 553 */ 554 555 556 var NAME$2 = 'carousel'; 557 var VERSION$2 = '4.3.1'; 558 var DATA_KEY$2 = 'bs.carousel'; 559 var EVENT_KEY$2 = "." + DATA_KEY$2; 560 var DATA_API_KEY$2 = '.data-api'; 561 var JQUERY_NO_CONFLICT$2 = $.fn[NAME$2]; 562 var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key 563 564 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key 565 566 var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 567 568 var SWIPE_THRESHOLD = 40; 569 var Default = { 570 interval: 5000, 571 keyboard: true, 572 slide: false, 573 pause: 'hover', 574 wrap: true, 575 touch: true 576 }; 577 var DefaultType = { 578 interval: '(number|boolean)', 579 keyboard: 'boolean', 580 slide: '(boolean|string)', 581 pause: '(string|boolean)', 582 wrap: 'boolean', 583 touch: 'boolean' 584 }; 585 var Direction = { 586 NEXT: 'next', 587 PREV: 'prev', 588 LEFT: 'left', 589 RIGHT: 'right' 590 }; 591 var Event$2 = { 592 SLIDE: "slide" + EVENT_KEY$2, 593 SLID: "slid" + EVENT_KEY$2, 594 KEYDOWN: "keydown" + EVENT_KEY$2, 595 MOUSEENTER: "mouseenter" + EVENT_KEY$2, 596 MOUSELEAVE: "mouseleave" + EVENT_KEY$2, 597 TOUCHSTART: "touchstart" + EVENT_KEY$2, 598 TOUCHMOVE: "touchmove" + EVENT_KEY$2, 599 TOUCHEND: "touchend" + EVENT_KEY$2, 600 POINTERDOWN: "pointerdown" + EVENT_KEY$2, 601 POINTERUP: "pointerup" + EVENT_KEY$2, 602 DRAG_START: "dragstart" + EVENT_KEY$2, 603 LOAD_DATA_API: "load" + EVENT_KEY$2 + DATA_API_KEY$2, 604 CLICK_DATA_API: "click" + EVENT_KEY$2 + DATA_API_KEY$2 605 }; 606 var ClassName$2 = { 607 CAROUSEL: 'carousel', 608 ACTIVE: 'active', 609 SLIDE: 'slide', 610 RIGHT: 'carousel-item-right', 611 LEFT: 'carousel-item-left', 612 NEXT: 'carousel-item-next', 613 PREV: 'carousel-item-prev', 614 ITEM: 'carousel-item', 615 POINTER_EVENT: 'pointer-event' 616 }; 617 var Selector$2 = { 618 ACTIVE: '.active', 619 ACTIVE_ITEM: '.active.carousel-item', 620 ITEM: '.carousel-item', 621 ITEM_IMG: '.carousel-item img', 622 NEXT_PREV: '.carousel-item-next, .carousel-item-prev', 623 INDICATORS: '.carousel-indicators',
624 DATA_SLIDE: '[data-slide], [data-slide-to]', 625 DATA_RIDE: '[data-ride="carousel"]' 626 }; 627 var PointerType = { 628 TOUCH: 'touch', 629 PEN: 'pen' 630 /** 631 * ------------------------------------------------------------------------ 632 * Class Definition 633 * ------------------------------------------------------------------------ 634 */ 635 636 }; 637 638 var Carousel = 639 /*#__PURE__*/ 640 function () { 641 function Carousel(element, config) { 642 this._items = null; 643 this._interval = null; 644 this._activeElement = null; 645 this._isPaused = false; 646 this._isSliding = false; 647 this.touchTimeout = null; 648 this.touchStartX = 0; 649 this.touchDeltaX = 0; 650 this._config = this._getConfig(config); 651 this._element = element; 652 this._indicatorsElement = this._element.querySelector(Selector$2.INDICATORS); 653 this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 654 this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent); 655 656 this._addEventListeners(); 657 } // Getters 658 659 660 var _proto = Carousel.prototype; // Public 661 662 _proto.next = function next() { 663 if (!this._isSliding) { 664 this._slide(Direction.NEXT); 665 } 666 }; 667 668 _proto.nextWhenVisible = function nextWhenVisible() { 669 // Don't call next when the page isn't visible 670 // or the carousel or its parent isn't visible 671 if (!document.hidden && $(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden') { 672 this.next(); 673 } 674 }; 675 676 _proto.prev = function prev() { 677 if (!this._isSliding) { 678 this._slide(Direction.PREV); 679 } 680 }; 681 682 _proto.pause = function pause(event) { 683 if (!event) { 684 this._isPaused = true; 685 } 686 687 if (this._element.querySelector(Selector$2.NEXT_PREV)) { 688 Util.triggerTransitionEnd(this._element); 689 this.cycle(true); 690 } 691 692 clearInterval(this._interval); 693 this._interval = null; 694 }; 695 696 _proto.cycle = function cycle(event) { 697 if (!event) { 698 this._isPaused = false; 699 } 700 701 if (this._interval) { 702 clearInterval(this._interval); 703 this._interval = null; 704 } 705 706 if (this._config.interval && !this._isPaused) { 707 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval); 708 } 709 }; 710 711 _proto.to = function to(index) { 712 var _this = this; 713 714 this._activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM); 715 716 var activeIndex = this._getItemIndex(this._activeElement); 717 718 if (index > this._items.length - 1 || index < 0) { 719 return; 720 } 721 722 if (this._isSliding) { 723 $(this._element).one(Event$2.SLID, function () { 724 return _this.to(index); 725 }); 726 return; 727 } 728 729 if (activeIndex === index) { 730 this.pause(); 731 this.cycle(); 732 return; 733 } 734 735 var direction = index > activeIndex ? Direction.NEXT : Direction.PREV; 736 737 this._slide(direction, this._items[index]); 738 }; 739 740 _proto.dispose = function dispose() { 741 $(this._element).off(EVENT_KEY$2); 742 $.removeData(this._element, DATA_KEY$2); 743 this._items = null; 744 this._config = null; 745 this._element = null; 746 this._interval = null; 747 this._isPaused = null; 748 this._isSliding = null; 749 this._activeElement = null; 750 this._indicatorsElement = null; 751 } // Private 752 ; 753 754 _proto._getConfig = function _getConfig(config) { 755 config = _objectSpread({}, Default, config); 756 Util.typeCheckConfig(NAME$2, config, DefaultType); 757 return config; 758 }; 759 760 _proto._handleSwipe = function _handleSwipe() { 761 var absDeltax = Math.abs(this.touchDeltaX); 762 763 if (absDeltax <= SWIPE_THRESHOLD) { 764 return; 765 } 766 767 var direction = absDeltax / this.touchDeltaX; // swipe left 768 769 if (direction > 0) { 770 this.prev(); 771 } // swipe right 772 773 774 if (direction < 0) { 775 this.next(); 776 } 777 }; 778 779 _proto._addEventListeners = function _addEventListeners() { 780 var _this2 = this; 781 782 if (this._config.keyboard) { 783 $(this._element).on(Event$2.KEYDOWN, function (event) { 784 return _this2._keydown(event); 785 }); 786 } 787 788 if (this._config.pause === 'hover') { 789 $(this._element).on(Event$2.MOUSEENTER, function (event) { 790 return _this2.pause(event); 791 }).on(Event$2.MOUSELEAVE, function (event) { 792 return _this2.cycle(event); 793 }); 794 } 795 796 if (this._config.touch) { 797 this._addTouchEventListeners(); 798 } 799 }; 800 801 _proto._addTouchEventListeners = function _addTouchEventListeners() { 802 var _this3 = this; 803 804 if (!this._touchSupported) { 805 return; 806 } 807 808 var start = function start(event) { 809 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 810 _this3.touchStartX = event.originalEvent.clientX; 811 } else if (!_this3._pointerEvent) { 812 _this3.touchStartX = event.originalEvent.touches[0].clientX; 813 } 814 }; 815 816 var move = function move(event) { 817 // ensure swiping with one touch and not pinching 818 if (event.originalEvent.touches && event.originalEvent.touches.length > 1) { 819 _this3.touchDeltaX = 0; 820 } else { 821 _this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX; 822 } 823 }; 824 825 var end = function end(event) { 826 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 827 _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX; 828 } 829 830 _this3._handleSwipe(); 831 832 if (_this3._config.pause === 'hover') {
833 // If it's a touch-enabled device, mouseenter/leave are fired as 834 // part of the mouse compatibility events on first tap - the carousel 835 // would stop cycling until user tapped out of it; 836 // here, we listen for touchend, explicitly pause the carousel 837 // (as if it's the second time we tap on it, mouseenter compat event 838 // is NOT fired) and after a timeout (to allow for mouse compatibility 839 // events to fire) we explicitly restart cycling 840 _this3.pause(); 841 842 if (_this3.touchTimeout) { 843 clearTimeout(_this3.touchTimeout); 844 } 845 846 _this3.touchTimeout = setTimeout(function (event) { 847 return _this3.cycle(event); 848 }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval); 849 } 850 }; 851 852 $(this._element.querySelectorAll(Selector$2.ITEM_IMG)).on(Event$2.DRAG_START, function (e) { 853 return e.preventDefault(); 854 }); 855 856 if (this._pointerEvent) { 857 $(this._element).on(Event$2.POINTERDOWN, function (event) { 858 return start(event); 859 }); 860 $(this._element).on(Event$2.POINTERUP, function (event) { 861 return end(event); 862 }); 863 864 this._element.classList.add(ClassName$2.POINTER_EVENT); 865 } else { 866 $(this._element).on(Event$2.TOUCHSTART, function (event) { 867 return start(event); 868 }); 869 $(this._element).on(Event$2.TOUCHMOVE, function (event) { 870 return move(event); 871 }); 872 $(this._element).on(Event$2.TOUCHEND, function (event) { 873 return end(event); 874 }); 875 } 876 }; 877 878 _proto._keydown = function _keydown(event) { 879 if (/input|textarea/i.test(event.target.tagName)) { 880 return; 881 } 882 883 switch (event.which) { 884 case ARROW_LEFT_KEYCODE: 885 event.preventDefault(); 886 this.prev(); 887 break; 888 889 case ARROW_RIGHT_KEYCODE: 890 event.preventDefault(); 891 this.next(); 892 break; 893 894 default: 895 } 896 }; 897 898 _proto._getItemIndex = function _getItemIndex(element) { 899 this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector$2.ITEM)) : []; 900 return this._items.indexOf(element); 901 }; 902 903 _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) { 904 var isNextDirection = direction === Direction.NEXT; 905 var isPrevDirection = direction === Direction.PREV; 906 907 var activeIndex = this._getItemIndex(activeElement); 908 909 var lastItemIndex = this._items.length - 1; 910 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; 911 912 if (isGoingToWrap && !this._config.wrap) { 913 return activeElement; 914 } 915 916 var delta = direction === Direction.PREV ? -1 : 1; 917 var itemIndex = (activeIndex + delta) % this._items.length; 918 return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex]; 919 }; 920 921 _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) { 922 var targetIndex = this._getItemIndex(relatedTarget); 923 924 var fromIndex = this._getItemIndex(this._element.querySelector(Selector$2.ACTIVE_ITEM)); 925 926 var slideEvent = $.Event(Event$2.SLIDE, { 927 relatedTarget: relatedTarget, 928 direction: eventDirectionName, 929 from: fromIndex, 930 to: targetIndex 931 }); 932 $(this._element).trigger(slideEvent); 933 return slideEvent; 934 }; 935 936 _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) { 937 if (this._indicatorsElement) { 938 var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector$2.ACTIVE)); 939 $(indicators).removeClass(ClassName$2.ACTIVE); 940 941 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)]; 942 943 if (nextIndicator) { 944 $(nextIndicator).addClass(ClassName$2.ACTIVE); 945 } 946 } 947 }; 948 949 _proto._slide = function _slide(direction, element) { 950 var _this4 = this; 951 952 var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM); 953 954 var activeElementIndex = this._getItemIndex(activeElement); 955 956 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); 957 958 var nextElementIndex = this._getItemIndex(nextElement); 959 960 var isCycling = Boolean(this._interval); 961 var directionalClassName; 962 var orderClassName; 963 var eventDirectionName; 964 965 if (direction === Direction.NEXT) { 966 directionalClassName = ClassName$2.LEFT; 967 orderClassName = ClassName$2.NEXT; 968 eventDirectionName = Direction.LEFT; 969 } else { 970 directionalClassName = ClassName$2.RIGHT; 971 orderClassName = ClassName$2.PREV; 972 eventDirectionName = Direction.RIGHT; 973 } 974 975 if (nextElement && $(nextElement).hasClass(ClassName$2.ACTIVE)) { 976 this._isSliding = false;
977 return; 978 } 979 980 var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); 981 982 if (slideEvent.isDefaultPrevented()) { 983 return; 984 } 985 986 if (!activeElement || !nextElement) { 987 // Some weirdness is happening, so we bail 988 return; 989 } 990 991 this._isSliding = true; 992 993 if (isCycling) { 994 this.pause(); 995 } 996 997 this._setActiveIndicatorElement(nextElement); 998 999 var slidEvent = $.Event(Event$2.SLID, { 1000 relatedTarget: nextElement, 1001 direction: eventDirectionName, 1002 from: activeElementIndex, 1003 to: nextElementIndex 1004 }); 1005 1006 if ($(this._element).hasClass(ClassName$2.SLIDE)) { 1007 $(nextElement).addClass(orderClassName); 1008 Util.reflow(nextElement); 1009 $(activeElement).addClass(directionalClassName); 1010 $(nextElement).addClass(directionalClassName); 1011 var nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10); 1012 1013 if (nextElementInterval) { 1014 this._config.defaultInterval = this._config.defaultInterval || this._config.interval; 1015 this._config.interval = nextElementInterval; 1016 } else { 1017 this._config.interval = this._config.defaultInterval || this._config.interval; 1018 } 1019 1020 var transitionDuration = Util.getTransitionDurationFromElement(activeElement); 1021 $(activeElement).one(Util.TRANSITION_END, function () { 1022 $(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName$2.ACTIVE); 1023 $(activeElement).removeClass(ClassName$2.ACTIVE + " " + orderClassName + " " + directionalClassName); 1024 _this4._isSliding = false; 1025 setTimeout(function () { 1026 return $(_this4._element).trigger(slidEvent); 1027 }, 0); 1028 }).emulateTransitionEnd(transitionDuration); 1029 } else { 1030 $(activeElement).removeClass(ClassName$2.ACTIVE); 1031 $(nextElement).addClass(ClassName$2.ACTIVE); 1032 this._isSliding = false; 1033 $(this._element).trigger(slidEvent); 1034 } 1035 1036 if (isCycling) { 1037 this.cycle(); 1038 } 1039 } // Static 1040 ; 1041 1042 Carousel._jQueryInterface = function _jQueryInterface(config) { 1043 return this.each(function () { 1044 var data = $(this).data(DATA_KEY$2); 1045 1046 var _config = _objectSpread({}, Default, $(this).data()); 1047 1048 if (typeof config === 'object') { 1049 _config = _objectSpread({}, _config, config); 1050 } 1051 1052 var action = typeof config === 'string' ? config : _config.slide; 1053 1054 if (!data) { 1055 data = new Carousel(this, _config); 1056 $(this).data(DATA_KEY$2, data); 1057 } 1058 1059 if (typeof config === 'number') { 1060 data.to(config); 1061 } else if (typeof action === 'string') { 1062 if (typeof data[action] === 'undefined') { 1063 throw new TypeError("No method named \"" + action + "\""); 1064 } 1065 1066 data[action](); 1067 } else if (_config.interval && _config.ride) { 1068 data.pause(); 1069 data.cycle(); 1070 } 1071 }); 1072 }; 1073 1074 Carousel._dataApiClickHandler = function _dataApiClickHandler(event) { 1075 var selector = Util.getSelectorFromElement(this); 1076 1077 if (!selector) { 1078 return; 1079 } 1080 1081 var target = $(selector)[0]; 1082 1083 if (!target || !$(target).hasClass(ClassName$2.CAROUSEL)) { 1084 return; 1085 } 1086 1087 var config = _objectSpread({}, $(target).data(), $(this).data()); 1088 1089 var slideIndex = this.getAttribute('data-slide-to'); 1090 1091 if (slideIndex) { 1092 config.interval = false; 1093 } 1094 1095 Carousel._jQueryInterface.call($(target), config); 1096 1097 if (slideIndex) { 1098 $(target).data(DATA_KEY$2).to(slideIndex); 1099 } 1100 1101 event.preventDefault(); 1102 }; 1103 1104 _createClass(Carousel, null, [{ 1105 key: "VERSION", 1106 get: function get() { 1107 return VERSION$2; 1108 } 1109 }, { 1110 key: "Default", 1111 get: function get() { 1112 return Default; 1113 } 1114 }]); 1115 1116 return Carousel; 1117 }(); 1118 /** 1119 * ------------------------------------------------------------------------ 1120 * Data Api implementation 1121 * ------------------------------------------------------------------------ 1122 */ 1123 1124 1125 $(document).on(Event$2.CLICK_DATA_API, Selector$2.DATA_SLIDE, Carousel._dataApiClickHandler); 1126 $(window).on(Event$2.LOAD_DATA_API, function () { 1127 var carousels = [].slice.call(document.querySelectorAll(Selector$2.DATA_RIDE)); 1128 1129 for (var i = 0, len = carousels.length; i < len; i++) {
1130 var $carousel = $(carousels[i]); 1131 1132 Carousel._jQueryInterface.call($carousel, $carousel.data()); 1133 } 1134 }); 1135 /** 1136 * ------------------------------------------------------------------------ 1137 * jQuery 1138 * ------------------------------------------------------------------------ 1139 */ 1140 1141 $.fn[NAME$2] = Carousel._jQueryInterface; 1142 $.fn[NAME$2].Constructor = Carousel; 1143 1144 $.fn[NAME$2].noConflict = function () { 1145 $.fn[NAME$2] = JQUERY_NO_CONFLICT$2; 1146 return Carousel._jQueryInterface; 1147 }; 1148 /** 1149 * ------------------------------------------------------------------------ 1150 * Constants 1151 * ------------------------------------------------------------------------ 1152 */ 1153 1154 1155 var NAME$3 = 'collapse'; 1156 var VERSION$3 = '4.3.1'; 1157 var DATA_KEY$3 = 'bs.collapse'; 1158 var EVENT_KEY$3 = "." + DATA_KEY$3; 1159 var DATA_API_KEY$3 = '.data-api'; 1160 var JQUERY_NO_CONFLICT$3 = $.fn[NAME$3]; 1161 var Default$1 = { 1162 toggle: true, 1163 parent: '' 1164 }; 1165 var DefaultType$1 = { 1166 toggle: 'boolean', 1167 parent: '(string|element)' 1168 }; 1169 var Event$3 = { 1170 SHOW: "show" + EVENT_KEY$3, 1171 SHOWN: "shown" + EVENT_KEY$3, 1172 HIDE: "hide" + EVENT_KEY$3, 1173 HIDDEN: "hidden" + EVENT_KEY$3, 1174 CLICK_DATA_API: "click" + EVENT_KEY$3 + DATA_API_KEY$3 1175 }; 1176 var ClassName$3 = { 1177 SHOW: 'show', 1178 COLLAPSE: 'collapse', 1179 COLLAPSING: 'collapsing', 1180 COLLAPSED: 'collapsed' 1181 }; 1182 var Dimension = { 1183 WIDTH: 'width', 1184 HEIGHT: 'height' 1185 }; 1186 var Selector$3 = { 1187 ACTIVES: '.show, .collapsing', 1188 DATA_TOGGLE: '[data-toggle="collapse"]' 1189 /** 1190 * ------------------------------------------------------------------------ 1191 * Class Definition 1192 * ------------------------------------------------------------------------ 1193 */ 1194 1195 }; 1196 1197 var Collapse = 1198 /*#__PURE__*/ 1199 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$3.DATA_TOGGLE)); 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; // Public 1234 1235 _proto.toggle = function toggle() { 1236 if ($(this._element).hasClass(ClassName$3.SHOW)) { 1237 this.hide(); 1238 } else { 1239 this.show(); 1240 } 1241 }; 1242 1243 _proto.show = function show() { 1244 var _this = this; 1245 1246 if (this._isTransitioning || $(this._element).hasClass(ClassName$3.SHOW)) { 1247 return; 1248 } 1249 1250 var actives; 1251 var activesData; 1252 1253 if (this._parent) { 1254 actives = [].slice.call(this._parent.querySelectorAll(Selector$3.ACTIVES)).filter(function (elem) { 1255 if (typeof _this._config.parent === 'string') { 1256 return elem.getAttribute('data-parent') === _this._config.parent; 1257 } 1258 1259 return elem.classList.contains(ClassName$3.COLLAPSE); 1260 }); 1261 1262 if (actives.length === 0) { 1263 actives = null; 1264 } 1265 } 1266 1267 if (actives) { 1268 activesData = $(actives).not(this._selector).data(DATA_KEY$3); 1269 1270 if (activesData && activesData._isTransitioning) { 1271 return; 1272 } 1273 } 1274 1275 var startEvent = $.Event(Event$3.SHOW); 1276 $(this._element).trigger(startEvent); 1277 1278 if (startEvent.isDefaultPrevented()) { 1279 return; 1280 } 1281 1282 if (actives) { 1283 Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide'); 1284 1285 if (!activesData) { 1286 $(actives).data(DATA_KEY$3, null); 1287 } 1288 } 1289 1290 var dimension = this._getDimension(); 1291 1292 $(this._element).removeClass(ClassName$3.COLLAPSE).addClass(ClassName$3.COLLAPSING); 1293 this._element.style[dimension] = 0; 1294 1295 if (this._triggerArray.length) { 1296 $(this._triggerArray).removeClass(ClassName$3.COLLAPSED).attr('aria-expanded', true); 1297 } 1298 1299 this.setTransitioning(true); 1300 1301 var complete = function complete() { 1302 $(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW); 1303 _this._element.style[dimension] = ''; 1304 1305 _this.setTransitioning(false); 1306 1307 $(_this._element).trigger(Event$3.SHOWN); 1308 }; 1309 1310 var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 1311 var scrollSize = "scroll" + capitalizedDimension; 1312 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1313 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1314 this._element.style[dimension] = this._element[scrollSize] + "px"; 1315 }; 1316 1317 _proto.hide = function hide() { 1318 var _this2 = this; 1319 1320 if (this._isTransitioning || !$(this._element).hasClass(ClassName$3.SHOW)) { 1321 return; 1322 } 1323 1324 var startEvent = $.Event(Event$3.HIDE); 1325 $(this._element).trigger(startEvent); 1326 1327 if (startEvent.isDefaultPrevented()) { 1328 return; 1329 } 1330 1331 var dimension = this._getDimension(); 1332 1333 this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px"; 1334 Util.reflow(this._element); 1335 $(this._element).addClass(ClassName$3.COLLAPSING).removeClass(ClassName$3.COLLAPSE).removeClass(ClassName$3.SHOW); 1336 var triggerArrayLength = this._triggerArray.length; 1337 1338 if (triggerArrayLength > 0) { 1339 for (var i = 0; i < triggerArrayLength; i++) { 1340 var trigger = this._triggerArray[i]; 1341 var selector = Util.getSelectorFromElement(trigger); 1342 1343 if (selector !== null) { 1344 var $elem = $([].slice.call(document.querySelectorAll(selector))); 1345 1346 if (!$elem.hasClass(ClassName$3.SHOW)) { 1347 $(trigger).addClass(ClassName$3.COLLAPSED).attr('aria-expanded', false); 1348 } 1349 } 1350 } 1351 } 1352 1353 this.setTransitioning(true); 1354 1355 var complete = function complete() { 1356 _this2.setTransitioning(false); 1357 1358 $(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN); 1359 }; 1360 1361 this._element.style[dimension] = ''; 1362 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1363 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1364 }; 1365 1366 _proto.setTransitioning = function setTransitioning(isTransitioning) { 1367 this._isTransitioning = isTransitioning; 1368 }; 1369 1370 _proto.dispose = function dispose() { 1371 $.removeData(this._element, DATA_KEY$3); 1372 this._config = null; 1373 this._parent = null; 1374 this._element = null; 1375 this._triggerArray = null; 1376 this._isTransitioning = null; 1377 } // Private 1378 ; 1379 1380 _proto._getConfig = function _getConfig(config) { 1381 config = _objectSpread({}, Default$1, config); 1382 config.toggle = Boolean(config.toggle); // Coerce string values 1383 1384 Util.typeCheckConfig(NAME$3, config, DefaultType$1); 1385 return config; 1386 }; 1387 1388 _proto._getDimension = function _getDimension() { 1389 var hasWidth = $(this._element).hasClass(Dimension.WIDTH); 1390 return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT; 1391 }; 1392 1393 _proto._getParent = function _getParent() { 1394 var _this3 = this; 1395 1396 var parent; 1397 1398 if (Util.isElement(this._config.parent)) { 1399 parent = this._config.parent; // It's a jQuery object 1400 1401 if (typeof this._config.parent.jquery !== 'undefined') { 1402 parent = this._config.parent[0]; 1403 } 1404 } else { 1405 parent = document.querySelector(this._config.parent); 1406 } 1407 1408 var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]"; 1409 var children = [].slice.call(parent.querySelectorAll(selector)); 1410 $(children).each(function (i, element) { 1411 _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]); 1412 }); 1413 return parent; 1414 }; 1415 1416 _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) { 1417 var isOpen = $(element).hasClass(ClassName$3.SHOW); 1418 1419 if (triggerArray.length) { 1420 $(triggerArray).toggleClass(ClassName$3.COLLAPSED, !isOpen).attr('aria-expanded', isOpen); 1421 } 1422 } // Static 1423 ; 1424 1425 Collapse._getTargetFromElement = function _getTargetFromElement(element) { 1426 var selector = Util.getSelectorFromElement(element); 1427 return selector ? document.querySelector(selector) : null; 1428 }; 1429 1430 Collapse._jQueryInterface = function _jQueryInterface(config) { 1431 return this.each(function () { 1432 var $this = $(this); 1433 var data = $this.data(DATA_KEY$3); 1434 1435 var _config = _objectSpread({}, Default$1, $this.data(), typeof config === 'object' && config ? config : {}); 1436 1437 if (!data && _config.toggle && /show|hide/.test(config)) { 1438 _config.toggle = false;
1439 } 1440 1441 if (!data) { 1442 data = new Collapse(this, _config); 1443 $this.data(DATA_KEY$3, data); 1444 } 1445 1446 if (typeof config === 'string') { 1447 if (typeof data[config] === 'undefined') { 1448 throw new TypeError("No method named \"" + config + "\""); 1449 } 1450 1451 data[config](); 1452 } 1453 }); 1454 }; 1455 1456 _createClass(Collapse, null, [{ 1457 key: "VERSION", 1458 get: function get() { 1459 return VERSION$3; 1460 } 1461 }, { 1462 key: "Default", 1463 get: function get() { 1464 return Default$1; 1465 } 1466 }]); 1467 1468 return Collapse; 1469 }(); 1470 /** 1471 * ------------------------------------------------------------------------ 1472 * Data Api implementation 1473 * ------------------------------------------------------------------------ 1474 */ 1475 1476 1477 $(document).on(Event$3.CLICK_DATA_API, Selector$3.DATA_TOGGLE, function (event) { 1478 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 1479 if (event.currentTarget.tagName === 'A') { 1480 event.preventDefault(); 1481 } 1482 1483 var $trigger = $(this); 1484 var selector = Util.getSelectorFromElement(this); 1485 var selectors = [].slice.call(document.querySelectorAll(selector)); 1486 $(selectors).each(function () { 1487 var $target = $(this); 1488 var data = $target.data(DATA_KEY$3); 1489 var config = data ? 'toggle' : $trigger.data(); 1490 1491 Collapse._jQueryInterface.call($target, config); 1492 }); 1493 }); 1494 /** 1495 * ------------------------------------------------------------------------ 1496 * jQuery 1497 * ------------------------------------------------------------------------ 1498 */ 1499 1500 $.fn[NAME$3] = Collapse._jQueryInterface; 1501 $.fn[NAME$3].Constructor = Collapse; 1502 1503 $.fn[NAME$3].noConflict = function () { 1504 $.fn[NAME$3] = JQUERY_NO_CONFLICT$3; 1505 return Collapse._jQueryInterface; 1506 }; 1507 /**! 1508 * @fileOverview Kickass library to create and place poppers near their reference elements. 1509 * @version 1.14.7 1510 * @license 1511 * Copyright (c) 2016 Federico Zivolo and contributors 1512 * 1513 * Permission is hereby granted, free of charge, to any person obtaining a copy 1514 * of this software and associated documentation files (the "Software"), to deal 1515 * in the Software without restriction, including without limitation the rights 1516 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1517 * copies of the Software, and to permit persons to whom the Software is 1518 * furnished to do so, subject to the following conditions: 1519 * 1520 * The above copyright notice and this permission notice shall be included in all 1521 * copies or substantial portions of the Software. 1522 * 1523 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1524 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 1525 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 1526 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 1527 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 1528 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 1529 * SOFTWARE. 1530 */ 1531 1532 1533 var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined'; 1534 var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox']; 1535 var timeoutDuration = 0; 1536 1537 for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) { 1538 if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) { 1539 timeoutDuration = 1; 1540 break; 1541 } 1542 } 1543 1544 function microtaskDebounce(fn) { 1545 var called = false; 1546 return function () { 1547 if (called) { 1548 return; 1549 } 1550 1551 called = true; 1552 window.Promise.resolve().then(function () { 1553 called = false; 1554 fn(); 1555 }); 1556 }; 1557 } 1558 1559 function taskDebounce(fn) { 1560 var scheduled = false; 1561 return function () { 1562 if (!scheduled) { 1563 scheduled = true; 1564 setTimeout(function () { 1565 scheduled = false; 1566 fn(); 1567 }, timeoutDuration); 1568 } 1569 }; 1570 } 1571 1572 var supportsMicroTasks = isBrowser && window.Promise; 1573 /** 1574 * Create a debounced version of a method, that's asynchronously deferred 1575 * but called in the minimum time possible. 1576 * 1577 * @method 1578 * @memberof Popper.Utils 1579 * @argument {Function} fn 1580 * @returns {Function} 1581 */ 1582 1583 var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce; 1584 /** 1585 * Check if the given variable is a function 1586 * @method 1587 * @memberof Popper.Utils 1588 * @argument {Any} functionToCheck - variable to check 1589 * @returns {Boolean} answer to: is a function? 1590 */ 1591 1592 function isFunction(functionToCheck) { 1593 var getType = {}; 1594 return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]'; 1595 } 1596 /** 1597 * Get CSS computed property of the given element 1598 * @method 1599 * @memberof Popper.Utils 1600 * @argument {Eement} element 1601 * @argument {String} property 1602 */ 1603 1604 1605 function getStyleComputedProperty(element, property) { 1606 if (element.nodeType !== 1) { 1607 return []; 1608 } // NOTE: 1 DOM access here 1609 1610 1611 var window = element.ownerDocument.defaultView; 1612 var css = window.getComputedStyle(element, null); 1613 return property ? css[property] : css; 1614 } 1615 /** 1616 * Returns the parentNode or the host of the element 1617 * @method 1618 * @memberof Popper.Utils 1619 * @argument {Element} element 1620 * @returns {Element} parent 1621 */ 1622 1623 1624 function getParentNode(element) { 1625 if (element.nodeName === 'HTML') { 1626 return element; 1627 } 1628 1629 return element.parentNode || element.host; 1630 } 1631 /** 1632 * Returns the scrolling parent of the given element 1633 * @method 1634 * @memberof Popper.Utils 1635 * @argument {Element} element 1636 * @returns {Element} scroll parent 1637 */ 1638 1639 1640 function getScrollParent(element) { 1641 // Return body, `getScroll` will take care to get the correct `scrollTop` from it 1642 if (!element) { 1643 return document.body; 1644 } 1645 1646 switch (element.nodeName) { 1647 case 'HTML': 1648 case 'BODY': 1649 return element.ownerDocument.body; 1650 1651 case '#document': 1652 return element.body; 1653 } // Firefox want us to check `-x` and `-y` variations as well 1654 1655 1656 var _getStyleComputedProp = getStyleComputedProperty(element), 1657 overflow = _getStyleComputedProp.overflow, 1658 overflowX = _getStyleComputedProp.overflowX, 1659 overflowY = _getStyleComputedProp.overflowY; 1660 1661 if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { 1662 return element; 1663 } 1664 1665 return getScrollParent(getParentNode(element)); 1666 } 1667 1668 var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode); 1669 var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent); 1670 /** 1671 * Determines if the browser is Internet Explorer 1672 * @method 1673 * @memberof Popper.Utils 1674 * @param {Number} version to check 1675 * @returns {Boolean} isIE 1676 */ 1677 1678 function isIE(version) { 1679 if (version === 11) { 1680 return isIE11; 1681 } 1682 1683 if (version === 10) { 1684 return isIE10; 1685 } 1686 1687 return isIE11 || isIE10; 1688 } 1689 /** 1690 * Returns the offset parent of the given element 1691 * @method 1692 * @memberof Popper.Utils 1693 * @argument {Element} element 1694 * @returns {Element} offset parent 1695 */ 1696 1697 1698 function getOffsetParent(element) { 1699 if (!element) { 1700 return document.documentElement; 1701 } 1702 1703 var noOffsetParent = isIE(10) ? document.body : null; // NOTE: 1 DOM access here 1704 1705 var offsetParent = element.offsetParent || null; // Skip hidden elements which don't have an offsetParent 1706 1707 while (offsetParent === noOffsetParent && element.nextElementSibling) { 1708 offsetParent = (element = element.nextElementSibling).offsetParent; 1709 } 1710
vendor: 23,053 bytes, lines 1711-2384
1711 var nodeName = offsetParent && offsetParent.nodeName; 1712 1713 if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') { 1714 return element ? element.ownerDocument.documentElement : document.documentElement; 1715 } // .offsetParent will return the closest TH, TD or TABLE in case 1716 // no offsetParent is present, I hate this job... 1717 1718 1719 if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') { 1720 return getOffsetParent(offsetParent); 1721 } 1722 1723 return offsetParent; 1724 } 1725 1726 function isOffsetContainer(element) { 1727 var nodeName = element.nodeName; 1728 1729 if (nodeName === 'BODY') { 1730 return false; 1731 } 1732 1733 return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element; 1734 } 1735 /** 1736 * Finds the root node (document, shadowDOM root) of the given element 1737 * @method 1738 * @memberof Popper.Utils 1739 * @argument {Element} node 1740 * @returns {Element} root node 1741 */ 1742 1743 1744 function getRoot(node) { 1745 if (node.parentNode !== null) { 1746 return getRoot(node.parentNode); 1747 } 1748 1749 return node; 1750 } 1751 /** 1752 * Finds the offset parent common to the two provided nodes 1753 * @method 1754 * @memberof Popper.Utils 1755 * @argument {Element} element1 1756 * @argument {Element} element2 1757 * @returns {Element} common offset parent 1758 */ 1759 1760 1761 function findCommonOffsetParent(element1, element2) { 1762 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 1763 if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) { 1764 return document.documentElement; 1765 } // Here we make sure to give as "start" the element that comes first in the DOM 1766 1767 1768 var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING; 1769 var start = order ? element1 : element2; 1770 var end = order ? element2 : element1; // Get common ancestor container 1771 1772 var range = document.createRange(); 1773 range.setStart(start, 0); 1774 range.setEnd(end, 0); 1775 var commonAncestorContainer = range.commonAncestorContainer; // Both nodes are inside #document 1776 1777 if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) { 1778 if (isOffsetContainer(commonAncestorContainer)) { 1779 return commonAncestorContainer; 1780 } 1781 1782 return getOffsetParent(commonAncestorContainer); 1783 } // one of the nodes is inside shadowDOM, find which one 1784 1785 1786 var element1root = getRoot(element1); 1787 1788 if (element1root.host) { 1789 return findCommonOffsetParent(element1root.host, element2); 1790 } else { 1791 return findCommonOffsetParent(element1, getRoot(element2).host); 1792 } 1793 } 1794 /** 1795 * Gets the scroll value of the given element in the given side (top and left) 1796 * @method 1797 * @memberof Popper.Utils 1798 * @argument {Element} element 1799 * @argument {String} side `top` or `left` 1800 * @returns {number} amount of scrolled pixels 1801 */ 1802 1803 1804 function getScroll(element) { 1805 var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top'; 1806 var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft'; 1807 var nodeName = element.nodeName; 1808 1809 if (nodeName === 'BODY' || nodeName === 'HTML') { 1810 var html = element.ownerDocument.documentElement; 1811 var scrollingElement = element.ownerDocument.scrollingElement || html; 1812 return scrollingElement[upperSide]; 1813 } 1814 1815 return element[upperSide]; 1816 } 1817 /* 1818 * Sum or subtract the element scroll values (left and top) from a given rect object 1819 * @method 1820 * @memberof Popper.Utils 1821 * @param {Object} rect - Rect object you want to change 1822 * @param {HTMLElement} element - The element from the function reads the scroll values 1823 * @param {Boolean} subtract - set to true if you want to subtract the scroll values 1824 * @return {Object} rect - The modifier rect object 1825 */ 1826 1827 1828 function includeScroll(rect, element) { 1829 var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 1830 var scrollTop = getScroll(element, 'top'); 1831 var scrollLeft = getScroll(element, 'left'); 1832 var modifier = subtract ? -1 : 1; 1833 rect.top += scrollTop * modifier; 1834 rect.bottom += scrollTop * modifier; 1835 rect.left += scrollLeft * modifier; 1836 rect.right += scrollLeft * modifier; 1837 return rect; 1838 } 1839 /* 1840 * Helper to detect borders of a given element 1841 * @method 1842 * @memberof Popper.Utils 1843 * @param {CSSStyleDeclaration} styles 1844 * Result of `getStyleComputedProperty` on the given element 1845 * @param {String} axis - `x` or `y` 1846 * @return {number} borders - The borders size of the given axis 1847 */ 1848 1849 1850 function getBordersSize(styles, axis) { 1851 var sideA = axis === 'x' ? 'Left' : 'Top'; 1852 var sideB = sideA === 'Left' ? 'Right' : 'Bottom'; 1853 return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10); 1854 } 1855 1856 function getSize(axis, body, html, computedStyle) { 1857 return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0); 1858 } 1859 1860 function getWindowSizes(document) { 1861 var body = document.body; 1862 var html = document.documentElement; 1863 var computedStyle = isIE(10) && getComputedStyle(html); 1864 return { 1865 height: getSize('Height', body, html, computedStyle), 1866 width: getSize('Width', body, html, computedStyle) 1867 }; 1868 } 1869 1870 var classCallCheck = function (instance, Constructor) { 1871 if (!(instance instanceof Constructor)) { 1872 throw new TypeError("Cannot call a class as a function"); 1873 } 1874 }; 1875 1876 var createClass = function () { 1877 function defineProperties(target, props) { 1878 for (var i = 0; i < props.length; i++) { 1879 var descriptor = props[i]; 1880 descriptor.enumerable = descriptor.enumerable || false; 1881 descriptor.configurable = true; 1882 if ("value" in descriptor) descriptor.writable = true; 1883 Object.defineProperty(target, descriptor.key, descriptor); 1884 } 1885 } 1886 1887 return function (Constructor, protoProps, staticProps) { 1888 if (protoProps) defineProperties(Constructor.prototype, protoProps); 1889 if (staticProps) defineProperties(Constructor, staticProps); 1890 return Constructor; 1891 }; 1892 }(); 1893 1894 var defineProperty = function (obj, key, value) { 1895 if (key in obj) { 1896 Object.defineProperty(obj, key, { 1897 value: value, 1898 enumerable: true, 1899 configurable: true, 1900 writable: true 1901 }); 1902 } else { 1903 obj[key] = value; 1904 } 1905 1906 return obj; 1907 }; 1908 1909 var _extends = Object.assign || function (target) { 1910 for (var i = 1; i < arguments.length; i++) { 1911 var source = arguments[i]; 1912 1913 for (var key in source) { 1914 if (Object.prototype.hasOwnProperty.call(source, key)) { 1915 target[key] = source[key]; 1916 } 1917 } 1918 } 1919 1920 return target; 1921 }; 1922 /** 1923 * Given element offsets, generate an output similar to getBoundingClientRect 1924 * @method 1925 * @memberof Popper.Utils 1926 * @argument {Object} offsets 1927 * @returns {Object} ClientRect like output 1928 */ 1929 1930 1931 function getClientRect(offsets) { 1932 return _extends({}, offsets, { 1933 right: offsets.left + offsets.width, 1934 bottom: offsets.top + offsets.height 1935 }); 1936 } 1937 /** 1938 * Get bounding client rect of given element 1939 * @method 1940 * @memberof Popper.Utils 1941 * @param {HTMLElement} element 1942 * @return {Object} client rect 1943 */ 1944 1945 1946 function getBoundingClientRect(element) { 1947 var rect = {}; // IE10 10 FIX: Please, don't ask, the element isn't 1948 // considered in DOM in some circumstances... 1949 // This isn't reproducible in IE10 compatibility mode of IE11 1950 1951 try { 1952 if (isIE(10)) { 1953 rect = element.getBoundingClientRect(); 1954 var scrollTop = getScroll(element, 'top'); 1955 var scrollLeft = getScroll(element, 'left'); 1956 rect.top += scrollTop; 1957 rect.left += scrollLeft; 1958 rect.bottom += scrollTop; 1959 rect.right += scrollLeft; 1960 } else { 1961 rect = element.getBoundingClientRect(); 1962 } 1963 } catch (e) {} 1964 1965 var result = { 1966 left: rect.left, 1967 top: rect.top, 1968 width: rect.right - rect.left, 1969 height: rect.bottom - rect.top 1970 }; // subtract scrollbar size from sizes 1971 1972 var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {}; 1973 var width = sizes.width || element.clientWidth || result.right - result.left; 1974 var height = sizes.height || element.clientHeight || result.bottom - result.top; 1975 var horizScrollbar = element.offsetWidth - width; 1976 var vertScrollbar = element.offsetHeight - height; // if an hypothetical scrollbar is detected, we must be sure it's not a `border` 1977 // we make this check conditional for performance reasons 1978 1979 if (horizScrollbar || vertScrollbar) { 1980 var styles = getStyleComputedProperty(element); 1981 horizScrollbar -= getBordersSize(styles, 'x'); 1982 vertScrollbar -= getBordersSize(styles, 'y'); 1983 result.width -= horizScrollbar; 1984 result.height -= vertScrollbar; 1985 } 1986 1987 return getClientRect(result); 1988 } 1989 1990 function getOffsetRectRelativeToArbitraryNode(children, parent) { 1991 var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 1992 var isIE10 = isIE(10); 1993 var isHTML = parent.nodeName === 'HTML'; 1994 var childrenRect = getBoundingClientRect(children); 1995 var parentRect = getBoundingClientRect(parent); 1996 var scrollParent = getScrollParent(children); 1997 var styles = getStyleComputedProperty(parent); 1998 var borderTopWidth = parseFloat(styles.borderTopWidth, 10); 1999 var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10); // In cases where the parent is fixed, we must ignore negative scroll in offset calc 2000 2001 if (fixedPosition && isHTML) { 2002 parentRect.top = Math.max(parentRect.top, 0); 2003 parentRect.left = Math.max(parentRect.left, 0); 2004 } 2005 2006 var offsets = getClientRect({ 2007 top: childrenRect.top - parentRect.top - borderTopWidth, 2008 left: childrenRect.left - parentRect.left - borderLeftWidth, 2009 width: childrenRect.width, 2010 height: childrenRect.height 2011 }); 2012 offsets.marginTop = 0; 2013 offsets.marginLeft = 0; // Subtract margins of documentElement in case it's being used as parent 2014 // we do this only on HTML because it's the only element that behaves 2015 // differently when margins are applied to it. The margins are included in 2016 // the box of the documentElement, in the other cases not. 2017 2018 if (!isIE10 && isHTML) { 2019 var marginTop = parseFloat(styles.marginTop, 10); 2020 var marginLeft = parseFloat(styles.marginLeft, 10); 2021 offsets.top -= borderTopWidth - marginTop; 2022 offsets.bottom -= borderTopWidth - marginTop; 2023 offsets.left -= borderLeftWidth - marginLeft; 2024 offsets.right -= borderLeftWidth - marginLeft; // Attach marginTop and marginLeft because in some circumstances we may need them 2025 2026 offsets.marginTop = marginTop; 2027 offsets.marginLeft = marginLeft; 2028 } 2029 2030 if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') { 2031 offsets = includeScroll(offsets, parent); 2032 } 2033 2034 return offsets; 2035 } 2036 2037 function getViewportOffsetRectRelativeToArtbitraryNode(element) { 2038 var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 2039 var html = element.ownerDocument.documentElement; 2040 var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html); 2041 var width = Math.max(html.clientWidth, window.innerWidth || 0); 2042 var height = Math.max(html.clientHeight, window.innerHeight || 0); 2043 var scrollTop = !excludeScroll ? getScroll(html) : 0; 2044 var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0; 2045 var offset = { 2046 top: scrollTop - relativeOffset.top + relativeOffset.marginTop, 2047 left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft, 2048 width: width, 2049 height: height 2050 }; 2051 return getClientRect(offset); 2052 } 2053 /** 2054 * Check if the given element is fixed or is inside a fixed parent 2055 * @method 2056 * @memberof Popper.Utils 2057 * @argument {Element} element 2058 * @argument {Element} customContainer 2059 * @returns {Boolean} answer to "isFixed?" 2060 */ 2061 2062 2063 function isFixed(element) { 2064 var nodeName = element.nodeName; 2065 2066 if (nodeName === 'BODY' || nodeName === 'HTML') { 2067 return false; 2068 } 2069 2070 if (getStyleComputedProperty(element, 'position') === 'fixed') { 2071 return true; 2072 } 2073 2074 var parentNode = getParentNode(element); 2075 2076 if (!parentNode) { 2077 return false; 2078 } 2079 2080 return isFixed(parentNode); 2081 } 2082 /** 2083 * Finds the first parent of an element that has a transformed property defined 2084 * @method 2085 * @memberof Popper.Utils 2086 * @argument {Element} element 2087 * @returns {Element} first transformed parent or documentElement 2088 */ 2089 2090 2091 function getFixedPositionOffsetParent(element) { 2092 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 2093 if (!element || !element.parentElement || isIE()) { 2094 return document.documentElement; 2095 } 2096 2097 var el = element.parentElement; 2098 2099 while (el && getStyleComputedProperty(el, 'transform') === 'none') { 2100 el = el.parentElement; 2101 } 2102 2103 return el || document.documentElement; 2104 } 2105 /** 2106 * Computed the boundaries limits and return them 2107 * @method 2108 * @memberof Popper.Utils 2109 * @param {HTMLElement} popper 2110 * @param {HTMLElement} reference 2111 * @param {number} padding 2112 * @param {HTMLElement} boundariesElement - Element used to define the boundaries 2113 * @param {Boolean} fixedPosition - Is in fixed position mode 2114 * @returns {Object} Coordinates of the boundaries 2115 */ 2116 2117 2118 function getBoundaries(popper, reference, padding, boundariesElement) { 2119 var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; // NOTE: 1 DOM access here 2120 2121 var boundaries = { 2122 top: 0, 2123 left: 0 2124 }; 2125 var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference); // Handle viewport case 2126 2127 if (boundariesElement === 'viewport') { 2128 boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition); 2129 } else { 2130 // Handle other cases based on DOM element used as boundaries 2131 var boundariesNode = void 0; 2132 2133 if (boundariesElement === 'scrollParent') { 2134 boundariesNode = getScrollParent(getParentNode(reference)); 2135 2136 if (boundariesNode.nodeName === 'BODY') { 2137 boundariesNode = popper.ownerDocument.documentElement; 2138 } 2139 } else if (boundariesElement === 'window') { 2140 boundariesNode = popper.ownerDocument.documentElement; 2141 } else { 2142 boundariesNode = boundariesElement; 2143 } 2144 2145 var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition); // In case of HTML, we need a different computation 2146 2147 if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) { 2148 var _getWindowSizes = getWindowSizes(popper.ownerDocument), 2149 height = _getWindowSizes.height, 2150 width = _getWindowSizes.width; 2151 2152 boundaries.top += offsets.top - offsets.marginTop; 2153 boundaries.bottom = height + offsets.top; 2154 boundaries.left += offsets.left - offsets.marginLeft; 2155 boundaries.right = width + offsets.left; 2156 } else { 2157 // for all the other DOM elements, this one is good 2158 boundaries = offsets; 2159 } 2160 } // Add paddings 2161 2162 2163 padding = padding || 0; 2164 var isPaddingNumber = typeof padding === 'number'; 2165 boundaries.left += isPaddingNumber ? padding : padding.left || 0; 2166 boundaries.top += isPaddingNumber ? padding : padding.top || 0; 2167 boundaries.right -= isPaddingNumber ? padding : padding.right || 0; 2168 boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0; 2169 return boundaries; 2170 } 2171 2172 function getArea(_ref) { 2173 var width = _ref.width, 2174 height = _ref.height; 2175 return width * height; 2176 } 2177 /** 2178 * Utility used to transform the `auto` placement to the placement with more 2179 * available space. 2180 * @method 2181 * @memberof Popper.Utils 2182 * @argument {Object} data - The data object generated by update method 2183 * @argument {Object} options - Modifiers configuration and options 2184 * @returns {Object} The data object, properly modified 2185 */ 2186 2187 2188 function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) { 2189 var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0; 2190 2191 if (placement.indexOf('auto') === -1) { 2192 return placement; 2193 } 2194 2195 var boundaries = getBoundaries(popper, reference, padding, boundariesElement); 2196 var rects = { 2197 top: { 2198 width: boundaries.width, 2199 height: refRect.top - boundaries.top 2200 }, 2201 right: { 2202 width: boundaries.right - refRect.right, 2203 height: boundaries.height 2204 }, 2205 bottom: { 2206 width: boundaries.width, 2207 height: boundaries.bottom - refRect.bottom 2208 }, 2209 left: { 2210 width: refRect.left - boundaries.left, 2211 height: boundaries.height 2212 } 2213 }; 2214 var sortedAreas = Object.keys(rects).map(function (key) { 2215 return _extends({ 2216 key: key 2217 }, rects[key], { 2218 area: getArea(rects[key]) 2219 }); 2220 }).sort(function (a, b) { 2221 return b.area - a.area; 2222 }); 2223 var filteredAreas = sortedAreas.filter(function (_ref2) { 2224 var width = _ref2.width, 2225 height = _ref2.height; 2226 return width >= popper.clientWidth && height >= popper.clientHeight; 2227 }); 2228 var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key; 2229 var variation = placement.split('-')[1]; 2230 return computedPlacement + (variation ? '-' + variation : ''); 2231 } 2232 /** 2233 * Get offsets to the reference element 2234 * @method 2235 * @memberof Popper.Utils 2236 * @param {Object} state 2237 * @param {Element} popper - the popper element 2238 * @param {Element} reference - the reference element (the popper will be relative to this) 2239 * @param {Element} fixedPosition - is in fixed position mode 2240 * @returns {Object} An object containing the offsets which will be applied to the popper 2241 */ 2242 2243 2244 function getReferenceOffsets(state, popper, reference) { 2245 var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; 2246 var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference); 2247 return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition); 2248 } 2249 /** 2250 * Get the outer sizes of the given element (offset size + margins) 2251 * @method 2252 * @memberof Popper.Utils 2253 * @argument {Element} element 2254 * @returns {Object} object containing width and height properties 2255 */ 2256 2257 2258 function getOuterSizes(element) { 2259 var window = element.ownerDocument.defaultView; 2260 var styles = window.getComputedStyle(element); 2261 var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0); 2262 var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0); 2263 var result = { 2264 width: element.offsetWidth + y, 2265 height: element.offsetHeight + x 2266 }; 2267 return result; 2268 } 2269 /** 2270 * Get the opposite placement of the given one 2271 * @method 2272 * @memberof Popper.Utils 2273 * @argument {String} placement 2274 * @returns {String} flipped placement 2275 */ 2276 2277 2278 function getOppositePlacement(placement) { 2279 var hash = { 2280 left: 'right', 2281 right: 'left', 2282 bottom: 'top', 2283 top: 'bottom' 2284 }; 2285 return placement.replace(/left|right|bottom|top/g, function (matched) { 2286 return hash[matched]; 2287 }); 2288 } 2289 /** 2290 * Get offsets to the popper 2291 * @method 2292 * @memberof Popper.Utils 2293 * @param {Object} position - CSS position the Popper will get applied 2294 * @param {HTMLElement} popper - the popper element 2295 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this) 2296 * @param {String} placement - one of the valid placement options 2297 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper 2298 */ 2299 2300 2301 function getPopperOffsets(popper, referenceOffsets, placement) { 2302 placement = placement.split('-')[0]; // Get popper node sizes 2303 2304 var popperRect = getOuterSizes(popper); // Add position, width and height to our offsets object 2305 2306 var popperOffsets = { 2307 width: popperRect.width, 2308 height: popperRect.height 2309 }; // depending by the popper placement we have to compute its offsets slightly differently 2310 2311 var isHoriz = ['right', 'left'].indexOf(placement) !== -1; 2312 var mainSide = isHoriz ? 'top' : 'left'; 2313 var secondarySide = isHoriz ? 'left' : 'top'; 2314 var measurement = isHoriz ? 'height' : 'width'; 2315 var secondaryMeasurement = !isHoriz ? 'height' : 'width'; 2316 popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2; 2317 2318 if (placement === secondarySide) { 2319 popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement]; 2320 } else { 2321 popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)]; 2322 } 2323 2324 return popperOffsets; 2325 } 2326 /** 2327 * Mimics the `find` method of Array 2328 * @method 2329 * @memberof Popper.Utils 2330 * @argument {Array} arr 2331 * @argument prop 2332 * @argument value 2333 * @returns index or -1 2334 */ 2335 2336 2337 function find(arr, check) { 2338 // use native find if supported 2339 if (Array.prototype.find) { 2340 return arr.find(check); 2341 } // use `filter` to obtain the same behavior of `find` 2342 2343 2344 return arr.filter(check)[0]; 2345 } 2346 /** 2347 * Return the index of the matching object 2348 * @method 2349 * @memberof Popper.Utils 2350 * @argument {Array} arr 2351 * @argument prop 2352 * @argument value 2353 * @returns index or -1 2354 */ 2355 2356 2357 function findIndex(arr, prop, value) { 2358 // use native findIndex if supported 2359 if (Array.prototype.findIndex) { 2360 return arr.findIndex(function (cur) { 2361 return cur[prop] === value; 2362 }); 2363 } // use `find` + `indexOf` if `findIndex` isn't supported 2364 2365 2366 var match = find(arr, function (obj) { 2367 return obj[prop] === value; 2368 }); 2369 return arr.indexOf(match); 2370 } 2371 /** 2372 * Loop trough the list of modifiers and run them in order, 2373 * each of them will then edit the data object. 2374 * @method 2375 * @memberof Popper.Utils 2376 * @param {dataObject} data 2377 * @param {Array} modifiers 2378 * @param {String} ends - Optional modifier name used as stopper 2379 * @returns {dataObject} 2380 */ 2381 2382 2383 function runModifiers(modifiers, data, ends) { 2384 var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
vendor: 8,549 bytes, lines 2385-2658
2385 modifiersToRun.forEach(function (modifier) { 2386 if (modifier['function']) { 2387 // eslint-disable-line dot-notation 2388 console.warn('`modifier.function` is deprecated, use `modifier.fn`!'); 2389 } 2390 2391 var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation 2392 2393 if (modifier.enabled && isFunction(fn)) { 2394 // Add properties to offsets to make them a complete clientRect object 2395 // we do this before each modifier to make sure the previous one doesn't 2396 // mess with these values 2397 data.offsets.popper = getClientRect(data.offsets.popper); 2398 data.offsets.reference = getClientRect(data.offsets.reference); 2399 data = fn(data, modifier); 2400 } 2401 }); 2402 return data; 2403 } 2404 /** 2405 * Updates the position of the popper, computing the new offsets and applying 2406 * the new style.<br /> 2407 * Prefer `scheduleUpdate` over `update` because of performance reasons. 2408 * @method 2409 * @memberof Popper 2410 */ 2411 2412 2413 function update() { 2414 // if popper is destroyed, don't perform any further update 2415 if (this.state.isDestroyed) { 2416 return; 2417 } 2418 2419 var data = { 2420 instance: this, 2421 styles: {}, 2422 arrowStyles: {}, 2423 attributes: {}, 2424 flipped: false, 2425 offsets: {} 2426 }; // compute reference element offsets 2427 2428 data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed); // compute auto placement, store placement inside the data object, 2429 // modifiers will be able to edit `placement` if needed 2430 // and refer to originalPlacement to know the original value 2431 2432 data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding); // store the computed placement inside `originalPlacement` 2433 2434 data.originalPlacement = data.placement; 2435 data.positionFixed = this.options.positionFixed; // compute the popper offsets 2436 2437 data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement); 2438 data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute'; // run the modifiers 2439 2440 data = runModifiers(this.modifiers, data); // the first `update` will call `onCreate` callback 2441 // the other ones will call `onUpdate` callback 2442 2443 if (!this.state.isCreated) { 2444 this.state.isCreated = true; 2445 this.options.onCreate(data); 2446 } else { 2447 this.options.onUpdate(data); 2448 } 2449 } 2450 /** 2451 * Helper used to know if the given modifier is enabled. 2452 * @method 2453 * @memberof Popper.Utils 2454 * @returns {Boolean} 2455 */ 2456 2457 2458 function isModifierEnabled(modifiers, modifierName) { 2459 return modifiers.some(function (_ref) { 2460 var name = _ref.name, 2461 enabled = _ref.enabled; 2462 return enabled && name === modifierName; 2463 }); 2464 } 2465 /** 2466 * Get the prefixed supported property name 2467 * @method 2468 * @memberof Popper.Utils 2469 * @argument {String} property (camelCase) 2470 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix) 2471 */ 2472 2473 2474 function getSupportedPropertyName(property) { 2475 var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O']; 2476 var upperProp = property.charAt(0).toUpperCase() + property.slice(1); 2477 2478 for (var i = 0; i < prefixes.length; i++) { 2479 var prefix = prefixes[i]; 2480 var toCheck = prefix ? '' + prefix + upperProp : property; 2481 2482 if (typeof document.body.style[toCheck] !== 'undefined') { 2483 return toCheck; 2484 } 2485 } 2486 2487 return null; 2488 } 2489 /** 2490 * Destroys the popper. 2491 * @method 2492 * @memberof Popper 2493 */ 2494 2495 2496 function destroy() { 2497 this.state.isDestroyed = true; // touch DOM only if `applyStyle` modifier is enabled 2498 2499 if (isModifierEnabled(this.modifiers, 'applyStyle')) { 2500 this.popper.removeAttribute('x-placement'); 2501 this.popper.style.position = ''; 2502 this.popper.style.top = ''; 2503 this.popper.style.left = ''; 2504 this.popper.style.right = ''; 2505 this.popper.style.bottom = ''; 2506 this.popper.style.willChange = ''; 2507 this.popper.style[getSupportedPropertyName('transform')] = ''; 2508 } 2509 2510 this.disableEventListeners(); // remove the popper if user explicity asked for the deletion on destroy 2511 // do not use `remove` because IE11 doesn't support it 2512 2513 if (this.options.removeOnDestroy) { 2514 this.popper.parentNode.removeChild(this.popper); 2515 } 2516 2517 return this; 2518 } 2519 /** 2520 * Get the window associated with the element 2521 * @argument {Element} element 2522 * @returns {Window} 2523 */ 2524 2525 2526 function getWindow(element) { 2527 var ownerDocument = element.ownerDocument; 2528 return ownerDocument ? ownerDocument.defaultView : window; 2529 } 2530 2531 function attachToScrollParents(scrollParent, event, callback, scrollParents) { 2532 var isBody = scrollParent.nodeName === 'BODY'; 2533 var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent; 2534 target.addEventListener(event, callback, { 2535 passive: true 2536 }); 2537 2538 if (!isBody) { 2539 attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents); 2540 } 2541 2542 scrollParents.push(target); 2543 } 2544 /** 2545 * Setup needed event listeners used to update the popper position 2546 * @method 2547 * @memberof Popper.Utils 2548 * @private 2549 */ 2550 2551 2552 function setupEventListeners(reference, options, state, updateBound) { 2553 // Resize event listener on window 2554 state.updateBound = updateBound; 2555 getWindow(reference).addEventListener('resize', state.updateBound, { 2556 passive: true 2557 }); // Scroll event listener on scroll parents 2558 2559 var scrollElement = getScrollParent(reference); 2560 attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents); 2561 state.scrollElement = scrollElement; 2562 state.eventsEnabled = true; 2563 return state; 2564 } 2565 /** 2566 * It will add resize/scroll events and start recalculating 2567 * position of the popper element when they are triggered. 2568 * @method 2569 * @memberof Popper 2570 */ 2571 2572 2573 function enableEventListeners() { 2574 if (!this.state.eventsEnabled) { 2575 this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate); 2576 } 2577 } 2578 /** 2579 * Remove event listeners used to update the popper position 2580 * @method 2581 * @memberof Popper.Utils 2582 * @private 2583 */ 2584 2585 2586 function removeEventListeners(reference, state) { 2587 // Remove resize event listener on window 2588 getWindow(reference).removeEventListener('resize', state.updateBound); // Remove scroll event listener on scroll parents 2589 2590 state.scrollParents.forEach(function (target) { 2591 target.removeEventListener('scroll', state.updateBound); 2592 }); // Reset state 2593 2594 state.updateBound = null; 2595 state.scrollParents = []; 2596 state.scrollElement = null; 2597 state.eventsEnabled = false; 2598 return state; 2599 } 2600 /** 2601 * It will remove resize/scroll events and won't recalculate popper position 2602 * when they are triggered. It also won't trigger `onUpdate` callback anymore, 2603 * unless you call `update` method manually. 2604 * @method 2605 * @memberof Popper 2606 */ 2607 2608 2609 function disableEventListeners() { 2610 if (this.state.eventsEnabled) { 2611 cancelAnimationFrame(this.scheduleUpdate); 2612 this.state = removeEventListeners(this.reference, this.state); 2613 } 2614 } 2615 /** 2616 * Tells if a given input is a number 2617 * @method 2618 * @memberof Popper.Utils 2619 * @param {*} input to check 2620 * @return {Boolean} 2621 */ 2622 2623 2624 function isNumeric(n) { 2625 return n !== '' && !isNaN(parseFloat(n)) && isFinite(n); 2626 } 2627 /** 2628 * Set the style to the given popper 2629 * @method 2630 * @memberof Popper.Utils 2631 * @argument {Element} element - Element to apply the style to 2632 * @argument {Object} styles 2633 * Object with a list of properties and values which will be applied to the element 2634 */ 2635 2636 2637 function setStyles(element, styles) { 2638 Object.keys(styles).forEach(function (prop) { 2639 var unit = ''; // add unit if the value is numeric and is one of the following 2640 2641 if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) { 2642 unit = 'px'; 2643 } 2644 2645 element.style[prop] = styles[prop] + unit; 2646 }); 2647 } 2648 /** 2649 * Set the attributes to the given popper 2650 * @method 2651 * @memberof Popper.Utils 2652 * @argument {Element} element - Element to apply the attributes to 2653 * @argument {Object} styles 2654 * Object with a list of properties and values which will be applied to the element 2655 */ 2656 2657 2658 function setAttributes(element, attributes) {
2659 Object.keys(attributes).forEach(function (prop) { 2660 var value = attributes[prop]; 2661 2662 if (value !== false) { 2663 element.setAttribute(prop, attributes[prop]); 2664 } else { 2665 element.removeAttribute(prop); 2666 } 2667 }); 2668 } 2669 /** 2670 * @function 2671 * @memberof Modifiers 2672 * @argument {Object} data - The data object generated by `update` method 2673 * @argument {Object} data.styles - List of style properties - values to apply to popper element 2674 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element 2675 * @argument {Object} options - Modifiers configuration and options 2676 * @returns {Object} The same data object 2677 */ 2678 2679 2680 function applyStyle(data) { 2681 // any property present in `data.styles` will be applied to the popper, 2682 // in this way we can make the 3rd party modifiers add custom styles to it 2683 // Be aware, modifiers could override the properties defined in the previous 2684 // lines of this modifier! 2685 setStyles(data.instance.popper, data.styles); // any property present in `data.attributes` will be applied to the popper, 2686 // they will be set as HTML attributes of the element 2687 2688 setAttributes(data.instance.popper, data.attributes); // if arrowElement is defined and arrowStyles has some properties 2689
vendor: 10,125 bytes, lines 2690-2944
2690 if (data.arrowElement && Object.keys(data.arrowStyles).length) { 2691 setStyles(data.arrowElement, data.arrowStyles); 2692 } 2693 2694 return data; 2695 } 2696 /** 2697 * Set the x-placement attribute before everything else because it could be used 2698 * to add margins to the popper margins needs to be calculated to get the 2699 * correct popper offsets. 2700 * @method 2701 * @memberof Popper.modifiers 2702 * @param {HTMLElement} reference - The reference element used to position the popper 2703 * @param {HTMLElement} popper - The HTML element used as popper 2704 * @param {Object} options - Popper.js options 2705 */ 2706 2707 2708 function applyStyleOnLoad(reference, popper, options, modifierOptions, state) { 2709 // compute reference element offsets 2710 var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed); // compute auto placement, store placement inside the data object, 2711 // modifiers will be able to edit `placement` if needed 2712 // and refer to originalPlacement to know the original value 2713 2714 var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding); 2715 popper.setAttribute('x-placement', placement); // Apply `position` to popper before anything else because 2716 // without the position applied we can't guarantee correct computations 2717 2718 setStyles(popper, { 2719 position: options.positionFixed ? 'fixed' : 'absolute' 2720 }); 2721 return options; 2722 } 2723 /** 2724 * @function 2725 * @memberof Popper.Utils 2726 * @argument {Object} data - The data object generated by `update` method 2727 * @argument {Boolean} shouldRound - If the offsets should be rounded at all 2728 * @returns {Object} The popper's position offsets rounded 2729 * 2730 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as 2731 * good as it can be within reason. 2732 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715 2733 * 2734 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari 2735 * as well on High DPI screens). 2736 * 2737 * Firefox prefers no rounding for positioning and does not have blurriness on 2738 * high DPI screens. 2739 * 2740 * Only horizontal placement and left/right values need to be considered. 2741 */ 2742 2743 2744 function getRoundedOffsets(data, shouldRound) { 2745 var _data$offsets = data.offsets, 2746 popper = _data$offsets.popper, 2747 reference = _data$offsets.reference; 2748 var round = Math.round, 2749 floor = Math.floor; 2750 2751 var noRound = function noRound(v) { 2752 return v; 2753 }; 2754 2755 var referenceWidth = round(reference.width); 2756 var popperWidth = round(popper.width); 2757 var isVertical = ['left', 'right'].indexOf(data.placement) !== -1; 2758 var isVariation = data.placement.indexOf('-') !== -1; 2759 var sameWidthParity = referenceWidth % 2 === popperWidth % 2; 2760 var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1; 2761 var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor; 2762 var verticalToInteger = !shouldRound ? noRound : round; 2763 return { 2764 left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left), 2765 top: verticalToInteger(popper.top), 2766 bottom: verticalToInteger(popper.bottom), 2767 right: horizontalToInteger(popper.right) 2768 }; 2769 } 2770 2771 var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent); 2772 /** 2773 * @function 2774 * @memberof Modifiers 2775 * @argument {Object} data - The data object generated by `update` method 2776 * @argument {Object} options - Modifiers configuration and options 2777 * @returns {Object} The data object, properly modified 2778 */ 2779 2780 function computeStyle(data, options) { 2781 var x = options.x, 2782 y = options.y; 2783 var popper = data.offsets.popper; // Remove this legacy support in Popper.js v2 2784 2785 var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) { 2786 return modifier.name === 'applyStyle'; 2787 }).gpuAcceleration; 2788 2789 if (legacyGpuAccelerationOption !== undefined) { 2790 console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!'); 2791 } 2792 2793 var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration; 2794 var offsetParent = getOffsetParent(data.instance.popper); 2795 var offsetParentRect = getBoundingClientRect(offsetParent); // Styles 2796 2797 var styles = { 2798 position: popper.position 2799 }; 2800 var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox); 2801 var sideA = x === 'bottom' ? 'top' : 'bottom'; 2802 var sideB = y === 'right' ? 'left' : 'right'; // if gpuAcceleration is set to `true` and transform is supported, 2803 // we use `translate3d` to apply the position to the popper we 2804 // automatically use the supported prefixed version if needed 2805 2806 var prefixedProperty = getSupportedPropertyName('transform'); // now, let's make a step back and look at this code closely (wtf?) 2807 // If the content of the popper grows once it's been positioned, it 2808 // may happen that the popper gets misplaced because of the new content 2809 // overflowing its reference element 2810 // To avoid this problem, we provide two options (x and y), which allow 2811 // the consumer to define the offset origin. 2812 // If we position a popper on top of a reference element, we can set 2813 // `x` to `top` to make the popper grow towards its top instead of 2814 // its bottom. 2815 2816 var left = void 0, 2817 top = void 0; 2818 2819 if (sideA === 'bottom') { 2820 // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar) 2821 // and not the bottom of the html element 2822 if (offsetParent.nodeName === 'HTML') { 2823 top = -offsetParent.clientHeight + offsets.bottom; 2824 } else { 2825 top = -offsetParentRect.height + offsets.bottom; 2826 } 2827 } else { 2828 top = offsets.top; 2829 } 2830 2831 if (sideB === 'right') { 2832 if (offsetParent.nodeName === 'HTML') { 2833 left = -offsetParent.clientWidth + offsets.right; 2834 } else { 2835 left = -offsetParentRect.width + offsets.right; 2836 } 2837 } else { 2838 left = offsets.left; 2839 } 2840 2841 if (gpuAcceleration && prefixedProperty) { 2842 styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)'; 2843 styles[sideA] = 0; 2844 styles[sideB] = 0; 2845 styles.willChange = 'transform'; 2846 } else { 2847 // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties 2848 var invertTop = sideA === 'bottom' ? -1 : 1; 2849 var invertLeft = sideB === 'right' ? -1 : 1; 2850 styles[sideA] = top * invertTop; 2851 styles[sideB] = left * invertLeft; 2852 styles.willChange = sideA + ', ' + sideB; 2853 } // Attributes 2854 2855 2856 var attributes = { 2857 'x-placement': data.placement 2858 }; // Update `data` attributes, styles and arrowStyles 2859 2860 data.attributes = _extends({}, attributes, data.attributes); 2861 data.styles = _extends({}, styles, data.styles); 2862 data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles); 2863 return data; 2864 } 2865 /** 2866 * Helper used to know if the given modifier depends from another one.<br /> 2867 * It checks if the needed modifier is listed and enabled. 2868 * @method 2869 * @memberof Popper.Utils 2870 * @param {Array} modifiers - list of modifiers 2871 * @param {String} requestingName - name of requesting modifier 2872 * @param {String} requestedName - name of requested modifier 2873 * @returns {Boolean} 2874 */ 2875 2876 2877 function isModifierRequired(modifiers, requestingName, requestedName) { 2878 var requesting = find(modifiers, function (_ref) { 2879 var name = _ref.name; 2880 return name === requestingName; 2881 }); 2882 var isRequired = !!requesting && modifiers.some(function (modifier) { 2883 return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order; 2884 }); 2885 2886 if (!isRequired) { 2887 var _requesting = '`' + requestingName + '`'; 2888 2889 var requested = '`' + requestedName + '`'; 2890 console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!'); 2891 } 2892 2893 return isRequired; 2894 } 2895 /** 2896 * @function 2897 * @memberof Modifiers 2898 * @argument {Object} data - The data object generated by update method 2899 * @argument {Object} options - Modifiers configuration and options 2900 * @returns {Object} The data object, properly modified 2901 */ 2902 2903 2904 function arrow(data, options) { 2905 var _data$offsets$arrow; // arrow depends on keepTogether in order to work 2906 2907 2908 if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) { 2909 return data; 2910 } 2911 2912 var arrowElement = options.element; // if arrowElement is a string, suppose it's a CSS selector 2913 2914 if (typeof arrowElement === 'string') { 2915 arrowElement = data.instance.popper.querySelector(arrowElement); // if arrowElement is not found, don't run the modifier 2916 2917 if (!arrowElement) { 2918 return data; 2919 } 2920 } else { 2921 // if the arrowElement isn't a query selector we must check that the 2922 // provided DOM node is child of its popper node 2923 if (!data.instance.popper.contains(arrowElement)) { 2924 console.warn('WARNING: `arrow.element` must be child of its popper element!'); 2925 return data; 2926 } 2927 } 2928 2929 var placement = data.placement.split('-')[0]; 2930 var _data$offsets = data.offsets, 2931 popper = _data$offsets.popper, 2932 reference = _data$offsets.reference; 2933 var isVertical = ['left', 'right'].indexOf(placement) !== -1; 2934 var len = isVertical ? 'height' : 'width'; 2935 var sideCapitalized = isVertical ? 'Top' : 'Left'; 2936 var side = sideCapitalized.toLowerCase(); 2937 var altSide = isVertical ? 'left' : 'top'; 2938 var opSide = isVertical ? 'bottom' : 'right'; 2939 var arrowElementSize = getOuterSizes(arrowElement)[len]; // 2940 // extends keepTogether behavior making sure the popper and its 2941 // reference have enough pixels in conjunction 2942 // 2943 // top/left side 2944
vendor: 5,648 bytes, lines 2945-3096
2945 if (reference[opSide] - arrowElementSize < popper[side]) { 2946 data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize); 2947 } // bottom/right side 2948 2949 2950 if (reference[side] + arrowElementSize > popper[opSide]) { 2951 data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide]; 2952 } 2953 2954 data.offsets.popper = getClientRect(data.offsets.popper); // compute center of the popper 2955 2956 var center = reference[side] + reference[len] / 2 - arrowElementSize / 2; // Compute the sideValue using the updated popper offsets 2957 // take popper margin in account because we don't have this info available 2958 2959 var css = getStyleComputedProperty(data.instance.popper); 2960 var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10); 2961 var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10); 2962 var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide; // prevent arrowElement from being placed not contiguously to its popper 2963 2964 sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0); 2965 data.arrowElement = arrowElement; 2966 data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow); 2967 return data; 2968 } 2969 /** 2970 * Get the opposite placement variation of the given one 2971 * @method 2972 * @memberof Popper.Utils 2973 * @argument {String} placement variation 2974 * @returns {String} flipped placement variation 2975 */ 2976 2977 2978 function getOppositeVariation(variation) { 2979 if (variation === 'end') { 2980 return 'start'; 2981 } else if (variation === 'start') { 2982 return 'end'; 2983 } 2984 2985 return variation; 2986 } 2987 /** 2988 * List of accepted placements to use as values of the `placement` option.<br /> 2989 * Valid placements are: 2990 * - `auto` 2991 * - `top` 2992 * - `right` 2993 * - `bottom` 2994 * - `left` 2995 * 2996 * Each placement can have a variation from this list: 2997 * - `-start` 2998 * - `-end` 2999 * 3000 * Variations are interpreted easily if you think of them as the left to right 3001 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` 3002 * is right.<br /> 3003 * Vertically (`left` and `right`), `start` is top and `end` is bottom. 3004 * 3005 * Some valid examples are: 3006 * - `top-end` (on top of reference, right aligned) 3007 * - `right-start` (on right of reference, top aligned) 3008 * - `bottom` (on bottom, centered) 3009 * - `auto-end` (on the side with more space available, alignment depends by placement) 3010 * 3011 * @static 3012 * @type {Array} 3013 * @enum {String} 3014 * @readonly 3015 * @method placements 3016 * @memberof Popper 3017 */ 3018 3019 3020 var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start']; // Get rid of `auto` `auto-start` and `auto-end` 3021 3022 var validPlacements = placements.slice(3); 3023 /** 3024 * Given an initial placement, returns all the subsequent placements 3025 * clockwise (or counter-clockwise). 3026 * 3027 * @method 3028 * @memberof Popper.Utils 3029 * @argument {String} placement - A valid placement (it accepts variations) 3030 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise 3031 * @returns {Array} placements including their variations 3032 */ 3033 3034 function clockwise(placement) { 3035 var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 3036 var index = validPlacements.indexOf(placement); 3037 var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index)); 3038 return counter ? arr.reverse() : arr; 3039 } 3040 3041 var BEHAVIORS = { 3042 FLIP: 'flip', 3043 CLOCKWISE: 'clockwise', 3044 COUNTERCLOCKWISE: 'counterclockwise' 3045 }; 3046 /** 3047 * @function 3048 * @memberof Modifiers 3049 * @argument {Object} data - The data object generated by update method 3050 * @argument {Object} options - Modifiers configuration and options 3051 * @returns {Object} The data object, properly modified 3052 */ 3053 3054 function flip(data, options) { 3055 // if `inner` modifier is enabled, we can't use the `flip` modifier 3056 if (isModifierEnabled(data.instance.modifiers, 'inner')) { 3057 return data; 3058 } 3059 3060 if (data.flipped && data.placement === data.originalPlacement) { 3061 // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides 3062 return data; 3063 } 3064 3065 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed); 3066 var placement = data.placement.split('-')[0]; 3067 var placementOpposite = getOppositePlacement(placement); 3068 var variation = data.placement.split('-')[1] || ''; 3069 var flipOrder = []; 3070 3071 switch (options.behavior) { 3072 case BEHAVIORS.FLIP: 3073 flipOrder = [placement, placementOpposite]; 3074 break; 3075 3076 case BEHAVIORS.CLOCKWISE: 3077 flipOrder = clockwise(placement); 3078 break; 3079 3080 case BEHAVIORS.COUNTERCLOCKWISE: 3081 flipOrder = clockwise(placement, true); 3082 break; 3083 3084 default: 3085 flipOrder = options.behavior; 3086 } 3087 3088 flipOrder.forEach(function (step, index) { 3089 if (placement !== step || flipOrder.length === index + 1) { 3090 return data; 3091 } 3092 3093 placement = data.placement.split('-')[0]; 3094 placementOpposite = getOppositePlacement(placement); 3095 var popperOffsets = data.offsets.popper; 3096 var refOffsets = data.offsets.reference; // using floor because the reference offsets may contain decimals we are not going to consider here
vendor: 1,693 bytes, lines 3097-3121
3097 3098 var floor = Math.floor; 3099 var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom); 3100 var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left); 3101 var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right); 3102 var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top); 3103 var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom); 3104 var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom; // flip the variation if required 3105 3106 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 3107 var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom); 3108 3109 if (overlapsRef || overflowsBoundaries || flippedVariation) { 3110 // this boolean to detect any flip loop 3111 data.flipped = true; 3112 3113 if (overlapsRef || overflowsBoundaries) { 3114 placement = flipOrder[index + 1]; 3115 } 3116 3117 if (flippedVariation) { 3118 variation = getOppositeVariation(variation); 3119 } 3120 3121 data.placement = placement + (variation ? '-' + variation : '');
vendor: 15,579 bytes, lines 3121-3548
3121 // this object contains `position`, we want to preserve it along with 3122 // any additional property we may add in the future 3123 3124 data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement)); 3125 data = runModifiers(data.instance.modifiers, data, 'flip'); 3126 } 3127 }); 3128 return data; 3129 } 3130 /** 3131 * @function 3132 * @memberof Modifiers 3133 * @argument {Object} data - The data object generated by update method 3134 * @argument {Object} options - Modifiers configuration and options 3135 * @returns {Object} The data object, properly modified 3136 */ 3137 3138 3139 function keepTogether(data) { 3140 var _data$offsets = data.offsets, 3141 popper = _data$offsets.popper, 3142 reference = _data$offsets.reference; 3143 var placement = data.placement.split('-')[0]; 3144 var floor = Math.floor; 3145 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 3146 var side = isVertical ? 'right' : 'bottom'; 3147 var opSide = isVertical ? 'left' : 'top'; 3148 var measurement = isVertical ? 'width' : 'height'; 3149 3150 if (popper[side] < floor(reference[opSide])) { 3151 data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement]; 3152 } 3153 3154 if (popper[opSide] > floor(reference[side])) { 3155 data.offsets.popper[opSide] = floor(reference[side]); 3156 } 3157 3158 return data; 3159 } 3160 /** 3161 * Converts a string containing value + unit into a px value number 3162 * @function 3163 * @memberof {modifiers~offset} 3164 * @private 3165 * @argument {String} str - Value + unit string 3166 * @argument {String} measurement - `height` or `width` 3167 * @argument {Object} popperOffsets 3168 * @argument {Object} referenceOffsets 3169 * @returns {Number|String} 3170 * Value in pixels, or original string if no values were extracted 3171 */ 3172 3173 3174 function toValue(str, measurement, popperOffsets, referenceOffsets) { 3175 // separate value from unit 3176 var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/); 3177 var value = +split[1]; 3178 var unit = split[2]; // If it's not a number it's an operator, I guess 3179 3180 if (!value) { 3181 return str; 3182 } 3183 3184 if (unit.indexOf('%') === 0) { 3185 var element = void 0; 3186 3187 switch (unit) { 3188 case '%p': 3189 element = popperOffsets; 3190 break; 3191 3192 case '%': 3193 case '%r': 3194 default: 3195 element = referenceOffsets; 3196 } 3197 3198 var rect = getClientRect(element); 3199 return rect[measurement] / 100 * value; 3200 } else if (unit === 'vh' || unit === 'vw') { 3201 // if is a vh or vw, we calculate the size based on the viewport 3202 var size = void 0; 3203 3204 if (unit === 'vh') { 3205 size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0); 3206 } else { 3207 size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0); 3208 } 3209 3210 return size / 100 * value; 3211 } else { 3212 // if is an explicit pixel unit, we get rid of the unit and keep the value 3213 // if is an implicit unit, it's px, and we return just the value 3214 return value; 3215 } 3216 } 3217 /** 3218 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets. 3219 * @function 3220 * @memberof {modifiers~offset} 3221 * @private 3222 * @argument {String} offset 3223 * @argument {Object} popperOffsets 3224 * @argument {Object} referenceOffsets 3225 * @argument {String} basePlacement 3226 * @returns {Array} a two cells array with x and y offsets in numbers 3227 */ 3228 3229 3230 function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) { 3231 var offsets = [0, 0]; // Use height if placement is left or right and index is 0 otherwise use width 3232 // in this way the first offset will use an axis and the second one 3233 // will use the other one 3234 3235 var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1; // Split the offset string to obtain a list of values and operands 3236 // The regex addresses values with the plus or minus sign in front (+10, -20, etc) 3237 3238 var fragments = offset.split(/(\+|\-)/).map(function (frag) { 3239 return frag.trim(); 3240 }); // Detect if the offset string contains a pair of values or a single one 3241 // they could be separated by comma or space 3242 3243 var divider = fragments.indexOf(find(fragments, function (frag) { 3244 return frag.search(/,|\s/) !== -1; 3245 })); 3246 3247 if (fragments[divider] && fragments[divider].indexOf(',') === -1) { 3248 console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.'); 3249 } // If divider is found, we divide the list of values and operands to divide 3250 // them by ofset X and Y. 3251 3252 3253 var splitRegex = /\s*,\s*|\s+/; 3254 var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments]; // Convert the values with units to absolute pixels to allow our computations 3255 3256 ops = ops.map(function (op, index) { 3257 // Most of the units rely on the orientation of the popper 3258 var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width'; 3259 var mergeWithPrevious = false; 3260 return op // This aggregates any `+` or `-` sign that aren't considered operators 3261 // e.g.: 10 + +5 => [10, +, +5] 3262 .reduce(function (a, b) { 3263 if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) { 3264 a[a.length - 1] = b; 3265 mergeWithPrevious = true; 3266 return a; 3267 } else if (mergeWithPrevious) { 3268 a[a.length - 1] += b; 3269 mergeWithPrevious = false; 3270 return a; 3271 } else { 3272 return a.concat(b); 3273 } 3274 }, []) // Here we convert the string values into number values (in px) 3275 .map(function (str) { 3276 return toValue(str, measurement, popperOffsets, referenceOffsets); 3277 }); 3278 }); // Loop trough the offsets arrays and execute the operations 3279 3280 ops.forEach(function (op, index) { 3281 op.forEach(function (frag, index2) { 3282 if (isNumeric(frag)) { 3283 offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1); 3284 } 3285 }); 3286 }); 3287 return offsets; 3288 } 3289 /** 3290 * @function 3291 * @memberof Modifiers 3292 * @argument {Object} data - The data object generated by update method 3293 * @argument {Object} options - Modifiers configuration and options 3294 * @argument {Number|String} options.offset=0 3295 * The offset value as described in the modifier description 3296 * @returns {Object} The data object, properly modified 3297 */ 3298 3299 3300 function offset(data, _ref) { 3301 var offset = _ref.offset; 3302 var placement = data.placement, 3303 _data$offsets = data.offsets, 3304 popper = _data$offsets.popper, 3305 reference = _data$offsets.reference; 3306 var basePlacement = placement.split('-')[0]; 3307 var offsets = void 0; 3308 3309 if (isNumeric(+offset)) { 3310 offsets = [+offset, 0]; 3311 } else { 3312 offsets = parseOffset(offset, popper, reference, basePlacement); 3313 } 3314 3315 if (basePlacement === 'left') { 3316 popper.top += offsets[0]; 3317 popper.left -= offsets[1]; 3318 } else if (basePlacement === 'right') { 3319 popper.top += offsets[0]; 3320 popper.left += offsets[1]; 3321 } else if (basePlacement === 'top') { 3322 popper.left += offsets[0]; 3323 popper.top -= offsets[1]; 3324 } else if (basePlacement === 'bottom') { 3325 popper.left += offsets[0]; 3326 popper.top += offsets[1]; 3327 } 3328 3329 data.popper = popper; 3330 return data; 3331 } 3332 /** 3333 * @function 3334 * @memberof Modifiers 3335 * @argument {Object} data - The data object generated by `update` method 3336 * @argument {Object} options - Modifiers configuration and options 3337 * @returns {Object} The data object, properly modified 3338 */ 3339 3340 3341 function preventOverflow(data, options) { 3342 var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper); // If offsetParent is the reference element, we really want to 3343 // go one step up and use the next offsetParent as reference to 3344 // avoid to make this modifier completely useless and look like broken 3345 3346 if (data.instance.reference === boundariesElement) { 3347 boundariesElement = getOffsetParent(boundariesElement); 3348 } // NOTE: DOM access here 3349 // resets the popper's position so that the document size can be calculated excluding 3350 // the size of the popper element itself 3351 3352 3353 var transformProp = getSupportedPropertyName('transform'); 3354 var popperStyles = data.instance.popper.style; // assignment to help minification 3355 3356 var top = popperStyles.top, 3357 left = popperStyles.left, 3358 transform = popperStyles[transformProp]; 3359 popperStyles.top = ''; 3360 popperStyles.left = ''; 3361 popperStyles[transformProp] = ''; 3362 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed); // NOTE: DOM access here 3363 // restores the original style properties after the offsets have been computed 3364 3365 popperStyles.top = top; 3366 popperStyles.left = left; 3367 popperStyles[transformProp] = transform; 3368 options.boundaries = boundaries; 3369 var order = options.priority; 3370 var popper = data.offsets.popper; 3371 var check = { 3372 primary: function primary(placement) { 3373 var value = popper[placement]; 3374 3375 if (popper[placement] < boundaries[placement] && !options.escapeWithReference) { 3376 value = Math.max(popper[placement], boundaries[placement]); 3377 } 3378 3379 return defineProperty({}, placement, value); 3380 }, 3381 secondary: function secondary(placement) { 3382 var mainSide = placement === 'right' ? 'left' : 'top'; 3383 var value = popper[mainSide]; 3384 3385 if (popper[placement] > boundaries[placement] && !options.escapeWithReference) { 3386 value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height)); 3387 } 3388 3389 return defineProperty({}, mainSide, value); 3390 } 3391 }; 3392 order.forEach(function (placement) { 3393 var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary'; 3394 popper = _extends({}, popper, check[side](placement)); 3395 }); 3396 data.offsets.popper = popper; 3397 return data; 3398 } 3399 /** 3400 * @function 3401 * @memberof Modifiers 3402 * @argument {Object} data - The data object generated by `update` method 3403 * @argument {Object} options - Modifiers configuration and options 3404 * @returns {Object} The data object, properly modified 3405 */ 3406 3407 3408 function shift(data) { 3409 var placement = data.placement; 3410 var basePlacement = placement.split('-')[0]; 3411 var shiftvariation = placement.split('-')[1]; // if shift shiftvariation is specified, run the modifier 3412 3413 if (shiftvariation) { 3414 var _data$offsets = data.offsets, 3415 reference = _data$offsets.reference, 3416 popper = _data$offsets.popper; 3417 var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1; 3418 var side = isVertical ? 'left' : 'top'; 3419 var measurement = isVertical ? 'width' : 'height'; 3420 var shiftOffsets = { 3421 start: defineProperty({}, side, reference[side]), 3422 end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement]) 3423 }; 3424 data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]); 3425 } 3426 3427 return data; 3428 } 3429 /** 3430 * @function 3431 * @memberof Modifiers 3432 * @argument {Object} data - The data object generated by update method 3433 * @argument {Object} options - Modifiers configuration and options 3434 * @returns {Object} The data object, properly modified 3435 */ 3436 3437 3438 function hide(data) { 3439 if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) { 3440 return data; 3441 } 3442 3443 var refRect = data.offsets.reference; 3444 var bound = find(data.instance.modifiers, function (modifier) { 3445 return modifier.name === 'preventOverflow'; 3446 }).boundaries; 3447 3448 if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) { 3449 // Avoid unnecessary DOM access if visibility hasn't changed 3450 if (data.hide === true) { 3451 return data; 3452 } 3453 3454 data.hide = true; 3455 data.attributes['x-out-of-boundaries'] = ''; 3456 } else { 3457 // Avoid unnecessary DOM access if visibility hasn't changed 3458 if (data.hide === false) { 3459 return data; 3460 } 3461 3462 data.hide = false; 3463 data.attributes['x-out-of-boundaries'] = false; 3464 } 3465 3466 return data; 3467 } 3468 /** 3469 * @function 3470 * @memberof Modifiers 3471 * @argument {Object} data - The data object generated by `update` method 3472 * @argument {Object} options - Modifiers configuration and options 3473 * @returns {Object} The data object, properly modified 3474 */ 3475 3476 3477 function inner(data) { 3478 var placement = data.placement; 3479 var basePlacement = placement.split('-')[0]; 3480 var _data$offsets = data.offsets, 3481 popper = _data$offsets.popper, 3482 reference = _data$offsets.reference; 3483 var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1; 3484 var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1; 3485 popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0); 3486 data.placement = getOppositePlacement(placement); 3487 data.offsets.popper = getClientRect(popper); 3488 return data; 3489 } 3490 /** 3491 * Modifier function, each modifier can have a function of this type assigned 3492 * to its `fn` property.<br /> 3493 * These functions will be called on each update, this means that you must 3494 * make sure they are performant enough to avoid performance bottlenecks. 3495 * 3496 * @function ModifierFn 3497 * @argument {dataObject} data - The data object generated by `update` method 3498 * @argument {Object} options - Modifiers configuration and options 3499 * @returns {dataObject} The data object, properly modified 3500 */ 3501 3502 /** 3503 * Modifiers are plugins used to alter the behavior of your poppers.<br /> 3504 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities 3505 * needed by the library. 3506 * 3507 * Usually you don't want to override the `order`, `fn` and `onLoad` props. 3508 * All the other properties are configurations that could be tweaked. 3509 * @namespace modifiers 3510 */ 3511 3512 3513 var modifiers = { 3514 /** 3515 * Modifier used to shift the popper on the start or end of its reference 3516 * element.<br /> 3517 * It will read the variation of the `placement` property.<br /> 3518 * It can be one either `-end` or `-start`. 3519 * @memberof modifiers 3520 * @inner 3521 */ 3522 shift: { 3523 /** @prop {number} order=100 - Index used to define the order of execution */ 3524 order: 100, 3525 3526 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3527 enabled: true, 3528 3529 /** @prop {ModifierFn} */ 3530 fn: shift 3531 }, 3532 3533 /** 3534 * The `offset` modifier can shift your popper on both its axis. 3535 * 3536 * It accepts the following units: 3537 * - `px` or unit-less, interpreted as pixels 3538 * - `%` or `%r`, percentage relative to the length of the reference element 3539 * - `%p`, percentage relative to the length of the popper element 3540 * - `vw`, CSS viewport width unit 3541 * - `vh`, CSS viewport height unit 3542 * 3543 * For length is intended the main axis relative to the placement of the popper.<br /> 3544 * This means that if the placement is `top` or `bottom`, the length will be the 3545 * `width`. In case of `left` or `right`, it will be the `height`. 3546 * 3547 * You can provide a single value (as `Number` or `String`), or a pair of values 3548 * as `String` divided by a comma or one (or more) white space
3548s.<br /> 3549 * The latter is a deprecated method because it leads to confusion and will be 3550 * removed in v2.<br /> 3551 * Additionally, it accepts additions and subtractions between different units. 3552 * Note that multiplications and divisions aren't supported. 3553 * 3554 * Valid examples are: 3555 * ``` 3556 * 10 3557 * '10%' 3558 * '10, 10' 3559 * '10%, 10' 3560 * '10 + 10%' 3561 * '10 - 5vh + 3%' 3562 * '-10px + 5vh, 5px - 6%' 3563 * ``` 3564 * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap 3565 * > with their reference element, unfortunately, you will have to disable the `flip` modifier. 3566 * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373). 3567 * 3568 * @memberof modifiers 3569 * @inner 3570 */ 3571 offset: { 3572 /** @prop {number} order=200 - Index used to define the order of execution */ 3573 order: 200, 3574 3575 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3576 enabled: true, 3577 3578 /** @prop {ModifierFn} */ 3579 fn: offset, 3580 3581 /** @prop {Number|String} offset=0 3582 * The offset value as described in the modifier description 3583 */ 3584 offset: 0 3585 }, 3586 3587 /** 3588 * Modifier used to prevent the popper from being positioned outside the boundary. 3589 * 3590 * A scenario exists where the reference itself is not within the boundaries.<br /> 3591 * We can say it has "escaped the boundaries" — or just "escaped".<br /> 3592 * In this case we need to decide whether the popper should either: 3593 * 3594 * - detach from the reference and remain "trapped" in the boundaries, or 3595 * - if it should ignore the boundary and "escape with its reference" 3596 * 3597 * When `escapeWithReference` is set to`true` and reference is completely 3598 * outside its boundaries, the popper will overflow (or completely leave) 3599 * the boundaries in order to remain attached to the edge of the reference. 3600 * 3601 * @memberof modifiers 3602 * @inner 3603 */ 3604 preventOverflow: { 3605 /** @prop {number} order=300 - Index used to define the order of execution */ 3606 order: 300, 3607 3608 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3609 enabled: true, 3610 3611 /** @prop {ModifierFn} */ 3612 fn: preventOverflow, 3613 3614 /** 3615 * @prop {Array} [priority=['left','right','top','bottom']] 3616 * Popper will try to prevent overflow following these priorities by default, 3617 * then, it could overflow on the left and on top of the `boundariesElement` 3618 */ 3619 priority: ['left', 'right', 'top', 'bottom'], 3620 3621 /** 3622 * @prop {number} padding=5 3623 * Amount of pixel used to define a minimum distance between the boundaries 3624 * and the popper. This makes sure the popper always has a little padding 3625 * between the edges of its container 3626 */ 3627 padding: 5, 3628 3629 /** 3630 * @prop {String|HTMLElement} boundariesElement='scrollParent' 3631 * Boundaries used by the modifier. Can be `scrollParent`, `window`, 3632 * `viewport` or any DOM element. 3633 */ 3634 boundariesElement: 'scrollParent' 3635 }, 3636 3637 /** 3638 * Modifier used to make sure the reference and its popper stay near each other 3639 * without leaving any gap between the two. Especially useful when the arrow is 3640 * enabled and you want to ensure that it points to its reference element. 3641 * It cares only about the first axis. You can still have poppers with margin 3642 * between the popper and its reference element. 3643 * @memberof modifiers 3644 * @inner 3645 */ 3646 keepTogether: { 3647 /** @prop {number} order=400 - Index used to define the order of execution */ 3648 order: 400, 3649 3650 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3651 enabled: true, 3652 3653 /** @prop {ModifierFn} */ 3654 fn: keepTogether 3655 }, 3656 3657 /** 3658 * This modifier is used to move the `arrowElement` of the popper to make 3659 * sure it is positioned between the reference element and its popper element. 3660 * It will read the outer size of the `arrowElement` node to detect how many 3661 * pixels of conjunction are needed. 3662 * 3663 * It has no effect if no `arrowElement` is provided. 3664 * @memberof modifiers 3665 * @inner 3666 */ 3667 arrow: { 3668 /** @prop {number} order=500 - Index used to define the order of execution */ 3669 order: 500, 3670 3671 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3672 enabled: true, 3673 3674 /** @prop {ModifierFn} */ 3675 fn: arrow, 3676 3677 /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */ 3678 element: '[x-arrow]' 3679 }, 3680 3681 /** 3682 * Modifier used to flip the popper's placement when it starts to overlap its 3683 * reference element. 3684 * 3685 * Requires the `preventOverflow` modifier before it in order to work. 3686 * 3687 * **NOTE:** this modifier will interrupt the current update cycle and will 3688 * restart it if it detects the need to flip the placement. 3689 * @memberof modifiers 3690 * @inner 3691 */ 3692 flip: { 3693 /** @prop {number} order=600 - Index used to define the order of execution */ 3694 order: 600, 3695 3696 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3697 enabled: true, 3698 3699 /** @prop {ModifierFn} */ 3700 fn: flip, 3701 3702 /** 3703 * @prop {String|Array} behavior='flip' 3704 * The behavior used to change the popper's placement. It can be one of 3705 * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid 3706 * placements (with optional variations) 3707 */ 3708 behavior: 'flip', 3709 3710 /** 3711 * @prop {number} padding=5 3712 * The popper will flip if it hits the edges of the `boundariesElement` 3713 */ 3714 padding: 5, 3715 3716 /** 3717 * @prop {String|HTMLElement} boundariesElement='viewport' 3718 * The element which will define the boundaries of the popper position. 3719 * The popper will never be placed outside of the defined boundaries 3720 * (except if `keepTogether` is enabled) 3721 */ 3722 boundariesElement: 'viewport' 3723 }, 3724 3725 /** 3726 * Modifier used to make the popper flow toward the inner of the reference element. 3727 * By default, when this modifier is disabled, the popper will be placed outside 3728 * the reference element. 3729 * @memberof modifiers 3730 * @inner 3731 */ 3732 inner: { 3733 /** @prop {number} order=700 - Index used to define the order of execution */ 3734 order: 700, 3735 3736 /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */ 3737 enabled: false, 3738 3739 /** @prop {ModifierFn} */ 3740 fn: inner 3741 }, 3742 3743 /** 3744 * Modifier used to hide the popper when its reference element is outside of the 3745 * popper boundaries. It will set a `x-out-of-boundaries` attribute which can 3746 * be used to hide with a CSS selector the popper when its reference is 3747 * out of boundaries. 3748 * 3749 * Requires the `preventOverflow` modifier before it in order to work. 3750 * @memberof modifiers 3751 * @inner 3752 */ 3753 hide: { 3754 /** @prop {number} order=800 - Index used to define the order of execution */ 3755 order: 800, 3756 3757 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3758 enabled: true, 3759 3760 /** @prop {ModifierFn} */ 3761 fn: hide 3762 }, 3763 3764 /** 3765 * Computes the style that will be applied to the popper element to gets 3766 * properly positioned. 3767 * 3768 * Note that this modifier will not touch the DOM, it just prepares the styles 3769 * so that `applyStyle` modifier can apply it. This separation is useful 3770 * in case you need to replace `applyStyle` with a custom implementation. 3771 * 3772 * This modifier has `850` as `order` value to maintain backward compatibility 3773 * with previous versions of Popper.js. Expect the modifiers ordering method 3774 * to change in future major versions of the library. 3775 * 3776 * @memberof modifiers 3777 * @inner 3778 */ 3779 computeStyle: { 3780 /** @prop {number} order=850 - Index used to define the order of execution */ 3781 order: 850, 3782 3783 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3784 enabled: true, 3785 3786 /** @prop {ModifierFn} */ 3787 fn: computeStyle, 3788 3789 /** 3790 * @prop {Boolean} gpuAcceleration=true 3791 * If true, it uses the CSS 3D transformation to position the popper. 3792 * Otherwise, it will use the `top` and `left` properties 3793 */ 3794 gpuAcceleration: true, 3795 3796 /** 3797 * @prop {string} [x='bottom'] 3798 * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin. 3799 * Change this if your popper should grow in a direction different from `bottom` 3800 */ 3801 x: 'bottom', 3802 3803 /** 3804 * @prop {string} [x='left'] 3805 * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin. 3806 * Change this if your popper should grow in a direction different from `right` 3807 */ 3808 y: 'right' 3809 }, 3810 3811 /** 3812 * Applies the computed styles to the popper element. 3813 * 3814 * All the DOM manipulations are limited to this modifier. This is useful in case 3815 * you want to integrate Popper.js inside a framework or view library and you 3816 * want to delegate all the DOM manipulations to it. 3817 * 3818 * Note that if you disable this modifier, you must make sure the popper element 3819 * has its position set to `absolute` before Popper.js can do its work! 3820 * 3821 * Just disable this modifier and define your own to achieve the desired effect. 3822 * 3823 * @memberof modifiers 3824 * @inner 3825 */ 3826 applyStyle: { 3827 /** @prop {number} order=900 - Index used to define the order of execution */ 3828 order: 900, 3829 3830 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 3831 enabled: true, 3832 3833 /** @prop {ModifierFn} */
vendor: 5,060 bytes, lines 3834-3971
3834 fn: applyStyle, 3835 3836 /** @prop {Function} */ 3837 onLoad: applyStyleOnLoad, 3838 3839 /** 3840 * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier 3841 * @prop {Boolean} gpuAcceleration=true 3842 * If true, it uses the CSS 3D transformation to position the popper. 3843 * Otherwise, it will use the `top` and `left` properties 3844 */ 3845 gpuAcceleration: undefined 3846 } 3847 }; 3848 /** 3849 * The `dataObject` is an object containing all the information used by Popper.js. 3850 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks. 3851 * @name dataObject 3852 * @property {Object} data.instance The Popper.js instance 3853 * @property {String} data.placement Placement applied to popper 3854 * @property {String} data.originalPlacement Placement originally defined on init 3855 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier 3856 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper 3857 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier 3858 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`) 3859 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`) 3860 * @property {Object} data.boundaries Offsets of the popper boundaries 3861 * @property {Object} data.offsets The measurements of popper, reference and arrow elements 3862 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values 3863 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values 3864 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0 3865 */ 3866 3867 /** 3868 * Default options provided to Popper.js constructor.<br /> 3869 * These can be overridden using the `options` argument of Popper.js.<br /> 3870 * To override an option, simply pass an object with the same 3871 * structure of the `options` object, as the 3rd argument. For example: 3872 * ``` 3873 * new Popper(ref, pop, { 3874 * modifiers: { 3875 * preventOverflow: { enabled: false } 3876 * } 3877 * }) 3878 * ``` 3879 * @type {Object} 3880 * @static 3881 * @memberof Popper 3882 */ 3883 3884 var Defaults = { 3885 /** 3886 * Popper's placement. 3887 * @prop {Popper.placements} placement='bottom' 3888 */ 3889 placement: 'bottom', 3890 3891 /** 3892 * Set this to true if you want popper to position it self in 'fixed' mode 3893 * @prop {Boolean} positionFixed=false 3894 */ 3895 positionFixed: false, 3896 3897 /** 3898 * Whether events (resize, scroll) are initially enabled. 3899 * @prop {Boolean} eventsEnabled=true 3900 */ 3901 eventsEnabled: true, 3902 3903 /** 3904 * Set to true if you want to automatically remove the popper when 3905 * you call the `destroy` method. 3906 * @prop {Boolean} removeOnDestroy=false 3907 */ 3908 removeOnDestroy: false, 3909 3910 /** 3911 * Callback called when the popper is created.<br /> 3912 * By default, it is set to no-op.<br /> 3913 * Access Popper.js instance with `data.instance`. 3914 * @prop {onCreate} 3915 */ 3916 onCreate: function onCreate() {}, 3917 3918 /** 3919 * Callback called when the popper is updated. This callback is not called 3920 * on the initialization/creation of the popper, but only on subsequent 3921 * updates.<br /> 3922 * By default, it is set to no-op.<br /> 3923 * Access Popper.js instance with `data.instance`. 3924 * @prop {onUpdate} 3925 */ 3926 onUpdate: function onUpdate() {}, 3927 3928 /** 3929 * List of modifiers used to modify the offsets before they are applied to the popper. 3930 * They provide most of the functionalities of Popper.js. 3931 * @prop {modifiers} 3932 */ 3933 modifiers: modifiers 3934 }; 3935 /** 3936 * @callback onCreate 3937 * @param {dataObject} data 3938 */ 3939 3940 /** 3941 * @callback onUpdate 3942 * @param {dataObject} data 3943 */ 3944 // Utils 3945 // Methods 3946 3947 var Popper = function () { 3948 /** 3949 * Creates a new Popper.js instance. 3950 * @class Popper 3951 * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper 3952 * @param {HTMLElement} popper - The HTML element used as the popper 3953 * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults) 3954 * @return {Object} instance - The generated Popper.js instance 3955 */ 3956 function Popper(reference, popper) { 3957 var _this = this; 3958 3959 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 3960 classCallCheck(this, Popper); 3961 3962 this.scheduleUpdate = function () { 3963 return requestAnimationFrame(_this.update); 3964 }; // make update() debounced, so that it only runs at most once-per-tick 3965 3966 3967 this.update = debounce(this.update.bind(this)); // with {} we create a new object with the options inside it 3968 3969 this.options = _extends({}, Popper.Defaults, options); // init state 3970 3971 this.state = {
3972 isDestroyed: false, 3973 isCreated: false, 3974 scrollParents: [] 3975 }; // get reference and popper elements (allow jQuery wrappers) 3976 3977 this.reference = reference && reference.jquery ? reference[0] : reference; 3978 this.popper = popper && popper.jquery ? popper[0] : popper; // Deep merge modifiers options 3979 3980 this.options.modifiers = {}; 3981 Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) { 3982 _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {}); 3983 }); // Refactoring modifiers' list (Object => Array) 3984 3985 this.modifiers = Object.keys(this.options.modifiers).map(function (name) { 3986 return _extends({ 3987 name: name 3988 }, _this.options.modifiers[name]); 3989 }) // sort the modifiers by order 3990 .sort(function (a, b) { 3991 return a.order - b.order; 3992 }); // modifiers have the ability to execute arbitrary code when Popper.js get inited 3993 // such code is executed in the same order of its modifier 3994 // they could add new properties to their options configuration 3995 // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`! 3996 3997 this.modifiers.forEach(function (modifierOptions) { 3998 if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) { 3999 modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state); 4000 } 4001 }); // fire the first update to position the popper in the right place 4002 4003 this.update(); 4004 var eventsEnabled = this.options.eventsEnabled; 4005 4006 if (eventsEnabled) { 4007 // setup event listeners, they will take care of update the position in specific situations 4008 this.enableEventListeners(); 4009 } 4010 4011 this.state.eventsEnabled = eventsEnabled; 4012 } // We can't use class properties because they don't get listed in the 4013 // class prototype and break stuff like Sinon stubs 4014 4015 4016 createClass(Popper, [{ 4017 key: 'update', 4018 value: function update$$1() { 4019 return update.call(this); 4020 } 4021 }, { 4022 key: 'destroy', 4023 value: function destroy$$1() { 4024 return destroy.call(this); 4025 } 4026 }, { 4027 key: 'enableEventListeners', 4028 value: function enableEventListeners$$1() { 4029 return enableEventListeners.call(this); 4030 } 4031 }, { 4032 key: 'disableEventListeners', 4033 value: function disableEventListeners$$1() { 4034 return disableEventListeners.call(this); 4035 } 4036 /** 4037 * Schedules an update. It will run on the next UI update available. 4038 * @method scheduleUpdate 4039 * @memberof Popper 4040 */ 4041 4042 /** 4043 * Collection of utilities useful when writing custom modifiers. 4044 * Starting from version 1.7, this method is available only if you 4045 * include `popper-utils.js` before `popper.js`. 4046 * 4047 * **DEPRECATION**: This way to access PopperUtils is deprecated 4048 * and will be removed in v2! Use the PopperUtils module directly instead. 4049 * Due to the high instability of the methods contained in Utils, we can't 4050 * guarantee them to follow semver. Use them at your own risk! 4051 * @static 4052 * @private 4053 * @type {Object} 4054 * @deprecated since version 1.8 4055 * @member Utils 4056 * @memberof Popper 4057 */ 4058 4059 }]); 4060 return Popper; 4061 }(); 4062 /** 4063 * The `referenceObject` is an object that provides an interface compatible with Popper.js 4064 * and lets you use it as replacement of a real DOM node.<br /> 4065 * You can use this method to position a popper relatively to a set of coordinates 4066 * in case you don't have a DOM node to use as reference. 4067 * 4068 * ``` 4069 * new Popper(referenceObject, popperNode); 4070 * ``` 4071 * 4072 * NB: This feature isn't supported in Internet Explorer 10. 4073 * @name referenceObject 4074 * @property {Function} data.getBoundingClientRect 4075 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. 4076 * @property {number} data.clientWidth 4077 * An ES6 getter that will return the width of the virtual reference element. 4078 * @property {number} data.clientHeight 4079 * An ES6 getter that will return the height of the virtual reference element. 4080 */ 4081 4082 4083 Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils; 4084 Popper.placements = placements; 4085 Popper.Defaults = Defaults; 4086 /** 4087 * ------------------------------------------------------------------------ 4088 * Constants 4089 * ------------------------------------------------------------------------ 4090 */ 4091 4092 var NAME$4 = 'dropdown'; 4093 var VERSION$4 = '4.3.1'; 4094 var DATA_KEY$4 = 'bs.dropdown'; 4095 var EVENT_KEY$4 = "." + DATA_KEY$4; 4096 var DATA_API_KEY$4 = '.data-api'; 4097 var JQUERY_NO_CONFLICT$4 = $.fn[NAME$4]; 4098 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 4099 4100 var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key 4101 4102 var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key 4103 4104 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key 4105 4106 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key 4107 4108 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) 4109 4110 var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE); 4111 var Event$4 = { 4112 HIDE: "hide" + EVENT_KEY$4, 4113 HIDDEN: "hidden" + EVENT_KEY$4, 4114 SHOW: "show" + EVENT_KEY$4, 4115 SHOWN: "shown" + EVENT_KEY$4, 4116 CLICK: "click" + EVENT_KEY$4, 4117 CLICK_DATA_API: "click" + EVENT_KEY$4 + DATA_API_KEY$4, 4118 KEYDOWN_DATA_API: "keydown" + EVENT_KEY$4 + DATA_API_KEY$4, 4119 KEYUP_DATA_API: "keyup" + EVENT_KEY$4 + DATA_API_KEY$4 4120 }; 4121 var ClassName$4 = { 4122 DISABLED: 'disabled', 4123 SHOW: 'show', 4124 DROPUP: 'dropup', 4125 DROPRIGHT: 'dropright', 4126 DROPLEFT: 'dropleft', 4127 MENURIGHT: 'dropdown-menu-right', 4128 MENULEFT: 'dropdown-menu-left', 4129 POSITION_STATIC: 'position-static' 4130 }; 4131 var Selector$4 = { 4132 DATA_TOGGLE: '[data-toggle="dropdown"]', 4133 FORM_CHILD: '.dropdown form', 4134 MENU: '.dropdown-menu', 4135 NAVBAR_NAV: '.navbar-nav', 4136 VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)' 4137 }; 4138 var AttachmentMap = { 4139 TOP: 'top-start', 4140 TOPEND: 'top-end', 4141 BOTTOM: 'bottom-start', 4142 BOTTOMEND: 'bottom-end', 4143 RIGHT: 'right-start', 4144 RIGHTEND: 'right-end', 4145 LEFT: 'left-start', 4146 LEFTEND: 'left-end' 4147 }; 4148 var Default$2 = { 4149 offset: 0, 4150 flip: true, 4151 boundary: 'scrollParent', 4152 reference: 'toggle', 4153 display: 'dynamic' 4154 }; 4155 var DefaultType$2 = { 4156 offset: '(number|string|function)', 4157 flip: 'boolean', 4158 boundary: '(string|element)', 4159 reference: '(string|element)', 4160 display: 'string' 4161 /** 4162 * ------------------------------------------------------------------------ 4163 * Class Definition 4164 * ------------------------------------------------------------------------ 4165 */ 4166 4167 }; 4168 4169 var Dropdown = 4170 /*#__PURE__*/ 4171 function () { 4172 function Dropdown(element, config) { 4173 this._element = element; 4174 this._popper = null; 4175 this._config = this._getConfig(config); 4176 this._menu = this._getMenuElement(); 4177 this._inNavbar = this._detectNavbar(); 4178 4179 this._addEventListeners(); 4180 } // Getters 4181 4182 4183 var _proto = Dropdown.prototype; // Public 4184
4185 _proto.toggle = function toggle() { 4186 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED)) { 4187 return; 4188 } 4189 4190 var parent = Dropdown._getParentFromElement(this._element); 4191 4192 var isActive = $(this._menu).hasClass(ClassName$4.SHOW); 4193 4194 Dropdown._clearMenus(); 4195 4196 if (isActive) { 4197 return; 4198 } 4199 4200 var relatedTarget = { 4201 relatedTarget: this._element 4202 }; 4203 var showEvent = $.Event(Event$4.SHOW, relatedTarget); 4204 $(parent).trigger(showEvent); 4205 4206 if (showEvent.isDefaultPrevented()) { 4207 return; 4208 } // Disable totally Popper.js for Dropdown in Navbar 4209 4210 4211 if (!this._inNavbar) { 4212 /** 4213 * Check for Popper dependency 4214 * Popper - https://popper.js.org 4215 */ 4216 if (typeof Popper === 'undefined') { 4217 throw new TypeError('Bootstrap\'s dropdowns require Popper.js (https://popper.js.org/)'); 4218 } 4219 4220 var referenceElement = this._element; 4221 4222 if (this._config.reference === 'parent') { 4223 referenceElement = parent; 4224 } else if (Util.isElement(this._config.reference)) { 4225 referenceElement = this._config.reference; // Check if it's jQuery element 4226 4227 if (typeof this._config.reference.jquery !== 'undefined') { 4228 referenceElement = this._config.reference[0]; 4229 } 4230 } // If boundary is not `scrollParent`, then set position to `static` 4231 // to allow the menu to "escape" the scroll parent's boundaries 4232 // https://github.com/twbs/bootstrap/issues/24251 4233 4234 4235 if (this._config.boundary !== 'scrollParent') { 4236 $(parent).addClass(ClassName$4.POSITION_STATIC); 4237 } 4238 4239 this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig()); 4240 } // If this is a touch-enabled device we add extra 4241 // empty mouseover listeners to the body's immediate children; 4242 // only needed because of broken event delegation on iOS 4243 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 4244 4245 4246 if ('ontouchstart' in document.documentElement && $(parent).closest(Selector$4.NAVBAR_NAV).length === 0) { 4247 $(document.body).children().on('mouseover', null, $.noop); 4248 } 4249 4250 this._element.focus(); 4251 4252 this._element.setAttribute('aria-expanded', true); 4253 4254 $(this._menu).toggleClass(ClassName$4.SHOW); 4255 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget)); 4256 }; 4257 4258 _proto.show = function show() { 4259 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || $(this._menu).hasClass(ClassName$4.SHOW)) { 4260 return; 4261 } 4262 4263 var relatedTarget = { 4264 relatedTarget: this._element 4265 }; 4266 var showEvent = $.Event(Event$4.SHOW, relatedTarget); 4267 4268 var parent = Dropdown._getParentFromElement(this._element); 4269 4270 $(parent).trigger(showEvent); 4271 4272 if (showEvent.isDefaultPrevented()) { 4273 return; 4274 } 4275 4276 $(this._menu).toggleClass(ClassName$4.SHOW); 4277 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget)); 4278 }; 4279 4280 _proto.hide = function hide() { 4281 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || !$(this._menu).hasClass(ClassName$4.SHOW)) { 4282 return; 4283 } 4284 4285 var relatedTarget = { 4286 relatedTarget: this._element 4287 }; 4288 var hideEvent = $.Event(Event$4.HIDE, relatedTarget); 4289 4290 var parent = Dropdown._getParentFromElement(this._element); 4291 4292 $(parent).trigger(hideEvent); 4293 4294 if (hideEvent.isDefaultPrevented()) { 4295 return; 4296 } 4297 4298 $(this._menu).toggleClass(ClassName$4.SHOW); 4299 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget)); 4300 }; 4301 4302 _proto.dispose = function dispose() { 4303 $.removeData(this._element, DATA_KEY$4); 4304 $(this._element).off(EVENT_KEY$4); 4305 this._element = null; 4306 this._menu = null; 4307 4308 if (this._popper !== null) { 4309 this._popper.destroy(); 4310 4311 this._popper = null; 4312 } 4313 }; 4314
4315 _proto.update = function update() { 4316 this._inNavbar = this._detectNavbar(); 4317 4318 if (this._popper !== null) { 4319 this._popper.scheduleUpdate(); 4320 } 4321 } // Private 4322 ; 4323 4324 _proto._addEventListeners = function _addEventListeners() { 4325 var _this = this; 4326 4327 $(this._element).on(Event$4.CLICK, function (event) { 4328 event.preventDefault(); 4329 event.stopPropagation(); 4330 4331 _this.toggle(); 4332 }); 4333 }; 4334 4335 _proto._getConfig = function _getConfig(config) { 4336 config = _objectSpread({}, this.constructor.Default, $(this._element).data(), config); 4337 Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType); 4338 return config; 4339 }; 4340 4341 _proto._getMenuElement = function _getMenuElement() { 4342 if (!this._menu) { 4343 var parent = Dropdown._getParentFromElement(this._element); 4344 4345 if (parent) { 4346 this._menu = parent.querySelector(Selector$4.MENU); 4347 } 4348 } 4349 4350 return this._menu; 4351 }; 4352 4353 _proto._getPlacement = function _getPlacement() { 4354 var $parentDropdown = $(this._element.parentNode); 4355 var placement = AttachmentMap.BOTTOM; // Handle dropup 4356 4357 if ($parentDropdown.hasClass(ClassName$4.DROPUP)) { 4358 placement = AttachmentMap.TOP; 4359 4360 if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) { 4361 placement = AttachmentMap.TOPEND; 4362 } 4363 } else if ($parentDropdown.hasClass(ClassName$4.DROPRIGHT)) { 4364 placement = AttachmentMap.RIGHT; 4365 } else if ($parentDropdown.hasClass(ClassName$4.DROPLEFT)) { 4366 placement = AttachmentMap.LEFT; 4367 } else if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) { 4368 placement = AttachmentMap.BOTTOMEND; 4369 } 4370 4371 return placement; 4372 }; 4373 4374 _proto._detectNavbar = function _detectNavbar() { 4375 return $(this._element).closest('.navbar').length > 0; 4376 }; 4377 4378 _proto._getOffset = function _getOffset() { 4379 var _this2 = this; 4380 4381 var offset = {}; 4382 4383 if (typeof this._config.offset === 'function') { 4384 offset.fn = function (data) { 4385 data.offsets = _objectSpread({}, data.offsets, _this2._config.offset(data.offsets, _this2._element) || {}); 4386 return data; 4387 }; 4388 } else { 4389 offset.offset = this._config.offset; 4390 } 4391 4392 return offset; 4393 }; 4394 4395 _proto._getPopperConfig = function _getPopperConfig() { 4396 var popperConfig = { 4397 placement: this._getPlacement(), 4398 modifiers: { 4399 offset: this._getOffset(), 4400 flip: { 4401 enabled: this._config.flip 4402 }, 4403 preventOverflow: { 4404 boundariesElement: this._config.boundary 4405 } 4406 } // Disable Popper.js if we have a static display 4407 4408 }; 4409 4410 if (this._config.display === 'static') { 4411 popperConfig.modifiers.applyStyle = { 4412 enabled: false 4413 }; 4414 } 4415 4416 return popperConfig; 4417 } // Static 4418 ; 4419 4420 Dropdown._jQueryInterface = function _jQueryInterface(config) { 4421 return this.each(function () { 4422 var data = $(this).data(DATA_KEY$4); 4423 4424 var _config = typeof config === 'object' ? config : null; 4425 4426 if (!data) { 4427 data = new Dropdown(this, _config); 4428 $(this).data(DATA_KEY$4, data); 4429 } 4430 4431 if (typeof config === 'string') { 4432 if (typeof data[config] === 'undefined') { 4433 throw new TypeError("No method named \"" + config + "\""); 4434 } 4435 4436 data[config](); 4437 } 4438 }); 4439 }; 4440 4441 Dropdown._clearMenus = function _clearMenus(event) { 4442 if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) { 4443 return; 4444 } 4445 4446 var toggles = [].slice.call(document.querySelectorAll(Selector$4.DATA_TOGGLE)); 4447 4448 for (var i = 0, len = toggles.length; i < len; i++) { 4449 var parent = Dropdown._getParentFromElement(toggles[i]); 4450 4451 var context = $(toggles[i]).data(DATA_KEY$4); 4452 var relatedTarget = { 4453 relatedTarget: toggles[i] 4454 }; 4455 4456 if (event && event.type === 'click') { 4457 relatedTarget.clickEvent = event; 4458 } 4459 4460 if (!context) { 4461 continue; 4462 } 4463 4464 var dropdownMenu = context._menu; 4465 4466 if (!$(parent).hasClass(ClassName$4.SHOW)) { 4467 continue; 4468 } 4469 4470 if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $.contains(parent, event.target)) { 4471 continue; 4472 } 4473 4474 var hideEvent = $.Event(Event$4.HIDE, relatedTarget); 4475 $(parent).trigger(hideEvent); 4476 4477 if (hideEvent.isDefaultPrevented()) { 4478 continue; 4479 } // If this is a touch-enabled device we remove the extra 4480 // empty mouseover listeners we added for iOS support 4481 4482 4483 if ('ontouchstart' in document.documentElement) { 4484 $(document.body).children().off('mouseover', null, $.noop); 4485 } 4486 4487 toggles[i].setAttribute('aria-expanded', 'false'); 4488 $(dropdownMenu).removeClass(ClassName$4.SHOW); 4489 $(parent).removeClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget)); 4490 } 4491 }; 4492 4493 Dropdown._getParentFromElement = function _getParentFromElement(element) { 4494 var parent; 4495 var selector = Util.getSelectorFromElement(element); 4496 4497 if (selector) { 4498 parent = document.querySelector(selector); 4499 } 4500 4501 return parent || element.parentNode; 4502 } // eslint-disable-next-line complexity 4503 ; 4504 4505 Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) { 4506 // If not input/textarea: 4507 // - And not a key in REGEXP_KEYDOWN => not a dropdown command 4508 // If input/textarea: 4509 // - If space key => not a dropdown command 4510 // - If key is other than escape 4511 // - If key is not up or down => not a dropdown command 4512 // - If trigger inside the menu =>
4512 not a dropdown command 4513 if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $(event.target).closest(Selector$4.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) { 4514 return; 4515 } 4516 4517 event.preventDefault(); 4518 event.stopPropagation(); 4519 4520 if (this.disabled || $(this).hasClass(ClassName$4.DISABLED)) { 4521 return; 4522 } 4523 4524 var parent = Dropdown._getParentFromElement(this); 4525 4526 var isActive = $(parent).hasClass(ClassName$4.SHOW); 4527 4528 if (!isActive || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) { 4529 if (event.which === ESCAPE_KEYCODE) { 4530 var toggle = parent.querySelector(Selector$4.DATA_TOGGLE); 4531 $(toggle).trigger('focus'); 4532 } 4533 4534 $(this).trigger('click'); 4535 return; 4536 } 4537 4538 var items = [].slice.call(parent.querySelectorAll(Selector$4.VISIBLE_ITEMS)); 4539 4540 if (items.length === 0) { 4541 return; 4542 } 4543 4544 var index = items.indexOf(event.target); 4545 4546 if (event.which === ARROW_UP_KEYCODE && index > 0) { 4547 // Up 4548 index--; 4549 } 4550 4551 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { 4552 // Down 4553 index++; 4554 } 4555 4556 if (index < 0) { 4557 index = 0; 4558 } 4559 4560 items[index].focus(); 4561 }; 4562 4563 _createClass(Dropdown, null, [{ 4564 key: "VERSION", 4565 get: function get() { 4566 return VERSION$4; 4567 } 4568 }, { 4569 key: "Default", 4570 get: function get() { 4571 return Default$2; 4572 } 4573 }, { 4574 key: "DefaultType", 4575 get: function get() { 4576 return DefaultType$2; 4577 } 4578 }]); 4579 4580 return Dropdown; 4581 }(); 4582 /** 4583 * ------------------------------------------------------------------------ 4584 * Data Api implementation 4585 * ------------------------------------------------------------------------ 4586 */ 4587 4588 4589 $(document).on(Event$4.KEYDOWN_DATA_API, Selector$4.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event$4.KEYDOWN_DATA_API, Selector$4.MENU, Dropdown._dataApiKeydownHandler).on(Event$4.CLICK_DATA_API + " " + Event$4.KEYUP_DATA_API, Dropdown._clearMenus).on(Event$4.CLICK_DATA_API, Selector$4.DATA_TOGGLE, function (event) { 4590 event.preventDefault(); 4591 event.stopPropagation(); 4592 4593 Dropdown._jQueryInterface.call($(this), 'toggle'); 4594 }).on(Event$4.CLICK_DATA_API, Selector$4.FORM_CHILD, function (e) { 4595 e.stopPropagation(); 4596 }); 4597 /** 4598 * ------------------------------------------------------------------------ 4599 * jQuery 4600 * ------------------------------------------------------------------------ 4601 */ 4602 4603 $.fn[NAME$4] = Dropdown._jQueryInterface; 4604 $.fn[NAME$4].Constructor = Dropdown; 4605 4606 $.fn[NAME$4].noConflict = function () { 4607 $.fn[NAME$4] = JQUERY_NO_CONFLICT$4; 4608 return Dropdown._jQueryInterface; 4609 }; 4610 /** 4611 * ------------------------------------------------------------------------ 4612 * Constants 4613 * ------------------------------------------------------------------------ 4614 */ 4615 4616 4617 var NAME$5 = 'modal'; 4618 var VERSION$5 = '4.3.1'; 4619 var DATA_KEY$5 = 'bs.modal'; 4620 var EVENT_KEY$5 = "." + DATA_KEY$5; 4621 var DATA_API_KEY$5 = '.data-api'; 4622 var JQUERY_NO_CONFLICT$5 = $.fn[NAME$5]; 4623 var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key 4624 4625 var Default$3 = { 4626 backdrop: true, 4627 keyboard: true, 4628 focus: true, 4629 show: true 4630 }; 4631 var DefaultType$3 = { 4632 backdrop: '(boolean|string)', 4633 keyboard: 'boolean', 4634 focus: 'boolean', 4635 show: 'boolean' 4636 }; 4637 var Event$5 = { 4638 HIDE: "hide" + EVENT_KEY$5, 4639 HIDDEN: "hidden" + EVENT_KEY$5, 4640 SHOW: "show" + EVENT_KEY$5, 4641 SHOWN: "shown" + EVENT_KEY$5, 4642 FOCUSIN: "focusin" + EVENT_KEY$5, 4643 RESIZE: "resize" + EVENT_KEY$5, 4644 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$5, 4645 KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY$5, 4646 MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY$5, 4647 MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY$5, 4648 CLICK_DATA_API: "click" + EVENT_KEY$5 + DATA_API_KEY$5 4649 }; 4650 var ClassName$5 = {
4651 SCROLLABLE: 'modal-dialog-scrollable', 4652 SCROLLBAR_MEASURER: 'modal-scrollbar-measure', 4653 BACKDROP: 'modal-backdrop', 4654 OPEN: 'modal-open', 4655 FADE: 'fade', 4656 SHOW: 'show' 4657 }; 4658 var Selector$5 = { 4659 DIALOG: '.modal-dialog', 4660 MODAL_BODY: '.modal-body', 4661 DATA_TOGGLE: '[data-toggle="modal"]', 4662 DATA_DISMISS: '[data-dismiss="modal"]', 4663 FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top', 4664 STICKY_CONTENT: '.sticky-top' 4665 /** 4666 * ------------------------------------------------------------------------ 4667 * Class Definition 4668 * ------------------------------------------------------------------------ 4669 */ 4670 4671 }; 4672 4673 var Modal = 4674 /*#__PURE__*/ 4675 function () { 4676 function Modal(element, config) { 4677 this._config = this._getConfig(config); 4678 this._element = element; 4679 this._dialog = element.querySelector(Selector$5.DIALOG); 4680 this._backdrop = null; 4681 this._isShown = false; 4682 this._isBodyOverflowing = false; 4683 this._ignoreBackdropClick = false; 4684 this._isTransitioning = false; 4685 this._scrollbarWidth = 0; 4686 } // Getters 4687 4688 4689 var _proto = Modal.prototype; // Public 4690 4691 _proto.toggle = function toggle(relatedTarget) { 4692 return this._isShown ? this.hide() : this.show(relatedTarget); 4693 }; 4694 4695 _proto.show = function show(relatedTarget) { 4696 var _this = this; 4697 4698 if (this._isShown || this._isTransitioning) { 4699 return; 4700 } 4701 4702 if ($(this._element).hasClass(ClassName$5.FADE)) { 4703 this._isTransitioning = true; 4704 } 4705 4706 var showEvent = $.Event(Event$5.SHOW, { 4707 relatedTarget: relatedTarget 4708 }); 4709 $(this._element).trigger(showEvent); 4710 4711 if (this._isShown || showEvent.isDefaultPrevented()) { 4712 return; 4713 } 4714 4715 this._isShown = true; 4716 4717 this._checkScrollbar(); 4718 4719 this._setScrollbar(); 4720 4721 this._adjustDialog(); 4722 4723 this._setEscapeEvent(); 4724 4725 this._setResizeEvent(); 4726 4727 $(this._element).on(Event$5.CLICK_DISMISS, Selector$5.DATA_DISMISS, function (event) { 4728 return _this.hide(event); 4729 }); 4730 $(this._dialog).on(Event$5.MOUSEDOWN_DISMISS, function () { 4731 $(_this._element).one(Event$5.MOUSEUP_DISMISS, function (event) { 4732 if ($(event.target).is(_this._element)) { 4733 _this._ignoreBackdropClick = true; 4734 } 4735 }); 4736 }); 4737 4738 this._showBackdrop(function () { 4739 return _this._showElement(relatedTarget); 4740 }); 4741 }; 4742 4743 _proto.hide = function hide(event) { 4744 var _this2 = this; 4745 4746 if (event) { 4747 event.preventDefault(); 4748 } 4749 4750 if (!this._isShown || this._isTransitioning) { 4751 return; 4752 } 4753 4754 var hideEvent = $.Event(Event$5.HIDE); 4755 $(this._element).trigger(hideEvent); 4756 4757 if (!this._isShown || hideEvent.isDefaultPrevented()) { 4758 return; 4759 } 4760 4761 this._isShown = false; 4762 var transition = $(this._element).hasClass(ClassName$5.FADE); 4763 4764 if (transition) { 4765 this._isTransitioning = true; 4766 } 4767 4768 this._setEscapeEvent(); 4769 4770 this._setResizeEvent(); 4771 4772 $(document).off(Event$5.FOCUSIN); 4773 $(this._element).removeClass(ClassName$5.SHOW); 4774 $(this._element).off(Event$5.CLICK_DISMISS); 4775 $(this._dialog).off(Event$5.MOUSEDOWN_DISMISS); 4776 4777 if (transition) { 4778 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 4779 $(this._element).one(Util.TRANSITION_END, function (event) { 4780 return _this2._hideModal(event); 4781 }).emulateTransitionEnd(transitionDuration); 4782 } else { 4783 this._hideModal(); 4784 } 4785 }; 4786 4787 _proto.dispose = function dispose() { 4788 [window, this._element, this._dialog].forEach(function (htmlElement) { 4789 return $(htmlElement).off(EVENT_KEY$5); 4790 }); 4791 /** 4792 * `document` has 2 events `Event.FOCUSIN` and `Event.CLICK_DATA_API` 4793 * Do not move `document` in `htmlElements` array 4794 * It will remove `Event.CLICK_DATA_API` event that should remain 4795 */ 4796 4797 $(document).off(Event$5.FOCUSIN); 4798 $.removeData(this._element, DATA_KEY$5); 4799 this._config = null; 4800 this._element = null; 4801 this._dialog = null; 4802 this._backdrop = null; 4803 this._isShown = null; 4804 this._isBodyOverflowing = null; 4805 this._ignoreBackdropClick = null; 4806 this._isTransitioning = null; 4807 this._scrollbarWidth = null; 4808 }; 4809 4810 _proto.handleUpdate = function handleUpdate() { 4811 this._adjustDialog(); 4812 } // Private 4813 ; 4814 4815 _proto._getConfig = function _getConfig(config) { 4816 config = _objectSpread({}, Default$3, config); 4817 Util.typeCheckConfig(NAME$5, config, DefaultType$3); 4818 return config; 4819 }; 4820 4821 _proto._showElement = function _showElement(relatedTarget) { 4822 var _this3 = this; 4823 4824 var transition = $(this._element).hasClass(ClassName$5.FADE); 4825 4826 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 4827 // Don't move modal's DOM position 4828 document.body.appendChild(this._element); 4829 } 4830 4831 this._element.style.display = 'block'; 4832 4833 this._element.removeAttribute('aria-hidden'); 4834 4835 this._element.setAttribute('aria-modal', true); 4836 4837 if ($(this._dialog).hasClass(ClassName$5.SCROLLABLE)) { 4838 this._dialog.querySelector(Selector$5.MODAL_BODY).scrollTop = 0; 4839 } else { 4840 this._element.scrollTop = 0; 4841 } 4842 4843 if (transition) { 4844 Util.reflow(this._element); 4845 } 4846 4847 $(this._element).addClass(ClassName$5.SHOW); 4848 4849 if (this._config.focus) { 4850 this._enforceFocus(); 4851 } 4852 4853 var shownEvent = $.Event(Event$5.SHOWN, { 4854 relatedTarget: relatedTarget 4855 }); 4856 4857 var transitionComplete = function transitionComplete() { 4858 if (_this3._config.focus) { 4859 _this3._element.focus(); 4860 } 4861 4862 _this3._isTransitioning = false;
4863 $(_this3._element).trigger(shownEvent); 4864 }; 4865 4866 if (transition) { 4867 var transitionDuration = Util.getTransitionDurationFromElement(this._dialog); 4868 $(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); 4869 } else { 4870 transitionComplete(); 4871 } 4872 }; 4873 4874 _proto._enforceFocus = function _enforceFocus() { 4875 var _this4 = this; 4876 4877 $(document).off(Event$5.FOCUSIN) // Guard against infinite focus loop 4878 .on(Event$5.FOCUSIN, function (event) { 4879 if (document !== event.target && _this4._element !== event.target && $(_this4._element).has(event.target).length === 0) { 4880 _this4._element.focus(); 4881 } 4882 }); 4883 }; 4884 4885 _proto._setEscapeEvent = function _setEscapeEvent() { 4886 var _this5 = this; 4887 4888 if (this._isShown && this._config.keyboard) { 4889 $(this._element).on(Event$5.KEYDOWN_DISMISS, function (event) { 4890 if (event.which === ESCAPE_KEYCODE$1) { 4891 event.preventDefault(); 4892 4893 _this5.hide(); 4894 } 4895 }); 4896 } else if (!this._isShown) { 4897 $(this._element).off(Event$5.KEYDOWN_DISMISS); 4898 } 4899 }; 4900 4901 _proto._setResizeEvent = function _setResizeEvent() { 4902 var _this6 = this; 4903 4904 if (this._isShown) { 4905 $(window).on(Event$5.RESIZE, function (event) { 4906 return _this6.handleUpdate(event); 4907 }); 4908 } else { 4909 $(window).off(Event$5.RESIZE); 4910 } 4911 }; 4912 4913 _proto._hideModal = function _hideModal() { 4914 var _this7 = this; 4915 4916 this._element.style.display = 'none'; 4917 4918 this._element.setAttribute('aria-hidden', true); 4919 4920 this._element.removeAttribute('aria-modal'); 4921 4922 this._isTransitioning = false; 4923 4924 this._showBackdrop(function () { 4925 $(document.body).removeClass(ClassName$5.OPEN); 4926 4927 _this7._resetAdjustments(); 4928 4929 _this7._resetScrollbar(); 4930 4931 $(_this7._element).trigger(Event$5.HIDDEN); 4932 }); 4933 }; 4934 4935 _proto._removeBackdrop = function _removeBackdrop() { 4936 if (this._backdrop) { 4937 $(this._backdrop).remove(); 4938 this._backdrop = null; 4939 } 4940 }; 4941 4942 _proto._showBackdrop = function _showBackdrop(callback) { 4943 var _this8 = this; 4944 4945 var animate = $(this._element).hasClass(ClassName$5.FADE) ? ClassName$5.FADE : ''; 4946 4947 if (this._isShown && this._config.backdrop) { 4948 this._backdrop = document.createElement('div'); 4949 this._backdrop.className = ClassName$5.BACKDROP; 4950 4951 if (animate) { 4952 this._backdrop.classList.add(animate); 4953 } 4954 4955 $(this._backdrop).appendTo(document.body); 4956 $(this._element).on(Event$5.CLICK_DISMISS, function (event) { 4957 if (_this8._ignoreBackdropClick) { 4958 _this8._ignoreBackdropClick = false; 4959 return; 4960 } 4961 4962 if (event.target !== event.currentTarget) { 4963 return; 4964 } 4965 4966 if (_this8._config.backdrop === 'static') { 4967 _this8._element.focus(); 4968 } else { 4969 _this8.hide(); 4970 } 4971 }); 4972 4973 if (animate) { 4974 Util.reflow(this._backdrop); 4975 } 4976 4977 $(this._backdrop).addClass(ClassName$5.SHOW); 4978 4979 if (!callback) { 4980 return; 4981 } 4982 4983 if (!animate) { 4984 callback(); 4985 return; 4986 } 4987 4988 var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 4989 $(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); 4990 } else if (!this._isShown && this._backdrop) { 4991 $(this._backdrop).removeClass(ClassName$5.SHOW); 4992 4993 var callbackRemove = function callbackRemove() { 4994 _this8._removeBackdrop(); 4995 4996 if (callback) { 4997 callback(); 4998 } 4999 }; 5000 5001 if ($(this._element).hasClass(ClassName$5.FADE)) { 5002 var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 5003 5004 $(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); 5005 } else { 5006 callbackRemove(); 5007 } 5008 } else if (callback) { 5009 callback(); 5010 } 5011 } // ---------------------------------------------------------------------- 5012 // the following methods are used to handle overflowing modals 5013 // todo (fat): these should probably be refactored out of modal.js 5014 // ---------------------------------------------------------------------- 5015 ; 5016
5017 _proto._adjustDialog = function _adjustDialog() { 5018 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 5019 5020 if (!this._isBodyOverflowing && isModalOverflowing) { 5021 this._element.style.paddingLeft = this._scrollbarWidth + "px"; 5022 } 5023 5024 if (this._isBodyOverflowing && !isModalOverflowing) { 5025 this._element.style.paddingRight = this._scrollbarWidth + "px"; 5026 } 5027 }; 5028 5029 _proto._resetAdjustments = function _resetAdjustments() { 5030 this._element.style.paddingLeft = ''; 5031 this._element.style.paddingRight = ''; 5032 }; 5033 5034 _proto._checkScrollbar = function _checkScrollbar() { 5035 var rect = document.body.getBoundingClientRect(); 5036 this._isBodyOverflowing = rect.left + rect.right < window.innerWidth; 5037 this._scrollbarWidth = this._getScrollbarWidth(); 5038 }; 5039 5040 _proto._setScrollbar = function _setScrollbar() { 5041 var _this9 = this; 5042 5043 if (this._isBodyOverflowing) { 5044 // Note: DOMNode.style.paddingRight returns the actual value or '' if not set 5045 // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set 5046 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT)); 5047 var stickyContent = [].slice.call(document.querySelectorAll(Selector$5.STICKY_CONTENT)); // Adjust fixed content padding 5048 5049 $(fixedContent).each(function (index, element) { 5050 var actualPadding = element.style.paddingRight; 5051 var calculatedPadding = $(element).css('padding-right'); 5052 $(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px"); 5053 }); // Adjust sticky content margin 5054 5055 $(stickyContent).each(function (index, element) { 5056 var actualMargin = element.style.marginRight; 5057 var calculatedMargin = $(element).css('margin-right'); 5058 $(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px"); 5059 }); // Adjust body padding 5060 5061 var actualPadding = document.body.style.paddingRight; 5062 var calculatedPadding = $(document.body).css('padding-right'); 5063 $(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px"); 5064 } 5065 5066 $(document.body).addClass(ClassName$5.OPEN); 5067 }; 5068 5069 _proto._resetScrollbar = function _resetScrollbar() { 5070 // Restore fixed content padding 5071 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT)); 5072 $(fixedContent).each(function (index, element) { 5073 var padding = $(element).data('padding-right'); 5074 $(element).removeData('padding-right'); 5075 element.style.paddingRight = padding ? padding : ''; 5076 }); // Restore sticky content 5077 5078 var elements = [].slice.call(document.querySelectorAll("" + Selector$5.STICKY_CONTENT)); 5079 $(elements).each(function (index, element) { 5080 var margin = $(element).data('margin-right'); 5081 5082 if (typeof margin !== 'undefined') { 5083 $(element).css('margin-right', margin).removeData('margin-right'); 5084 } 5085 }); // Restore body padding 5086 5087 var padding = $(document.body).data('padding-right'); 5088 $(document.body).removeData('padding-right'); 5089 document.body.style.paddingRight = padding ? padding : ''; 5090 }; 5091 5092 _proto._getScrollbarWidth = function _getScrollbarWidth() { 5093 // thx d.walsh 5094 var scrollDiv = document.createElement('div'); 5095 scrollDiv.className = ClassName$5.SCROLLBAR_MEASURER; 5096 document.body.appendChild(scrollDiv); 5097 var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; 5098 document.body.removeChild(scrollDiv); 5099 return scrollbarWidth; 5100 } // Static 5101 ; 5102 5103 Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) { 5104 return this.each(function () { 5105 var data = $(this).data(DATA_KEY$5); 5106 5107 var _config = _objectSpread({}, Default$3, $(this).data(), typeof config === 'object' && config ? config : {}); 5108 5109 if (!data) { 5110 data = new Modal(this, _config); 5111 $(this).data(DATA_KEY$5, data); 5112 } 5113 5114 if (typeof config === 'string') { 5115 if (typeof data[config] === 'undefined') {
5116 throw new TypeError("No method named \"" + config + "\""); 5117 } 5118 5119 data[config](relatedTarget); 5120 } else if (_config.show) { 5121 data.show(relatedTarget); 5122 } 5123 }); 5124 }; 5125 5126 _createClass(Modal, null, [{ 5127 key: "VERSION", 5128 get: function get() { 5129 return VERSION$5; 5130 } 5131 }, { 5132 key: "Default", 5133 get: function get() { 5134 return Default$3; 5135 } 5136 }]); 5137 5138 return Modal; 5139 }(); 5140 /** 5141 * ------------------------------------------------------------------------ 5142 * Data Api implementation 5143 * ------------------------------------------------------------------------ 5144 */ 5145 5146 5147 $(document).on(Event$5.CLICK_DATA_API, Selector$5.DATA_TOGGLE, function (event) { 5148 var _this10 = this; 5149 5150 var target; 5151 var selector = Util.getSelectorFromElement(this); 5152 5153 if (selector) { 5154 target = document.querySelector(selector); 5155 } 5156 5157 var config = $(target).data(DATA_KEY$5) ? 'toggle' : _objectSpread({}, $(target).data(), $(this).data()); 5158 5159 if (this.tagName === 'A' || this.tagName === 'AREA') { 5160 event.preventDefault(); 5161 } 5162 5163 var $target = $(target).one(Event$5.SHOW, function (showEvent) { 5164 if (showEvent.isDefaultPrevented()) { 5165 // Only register focus restorer if modal will actually get shown 5166 return; 5167 } 5168 5169 $target.one(Event$5.HIDDEN, function () { 5170 if ($(_this10).is(':visible')) { 5171 _this10.focus(); 5172 } 5173 }); 5174 }); 5175 5176 Modal._jQueryInterface.call($(target), config, this); 5177 }); 5178 /** 5179 * ------------------------------------------------------------------------ 5180 * jQuery 5181 * ------------------------------------------------------------------------ 5182 */ 5183 5184 $.fn[NAME$5] = Modal._jQueryInterface; 5185 $.fn[NAME$5].Constructor = Modal; 5186 5187 $.fn[NAME$5].noConflict = function () { 5188 $.fn[NAME$5] = JQUERY_NO_CONFLICT$5; 5189 return Modal._jQueryInterface; 5190 }; 5191 /** 5192 * -------------------------------------------------------------------------- 5193 * Bootstrap (v4.3.1): tools/sanitizer.js 5194 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 5195 * -------------------------------------------------------------------------- 5196 */ 5197 5198 5199 var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']; 5200 var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 5201 var DefaultWhitelist = { 5202 // Global attributes allowed on any supplied element below. 5203 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 5204 a: ['target', 'href', 'title', 'rel'], 5205 area: [], 5206 b: [], 5207 br: [], 5208 col: [], 5209 code: [], 5210 div: [], 5211 em: [], 5212 hr: [], 5213 h1: [], 5214 h2: [], 5215 h3: [], 5216 h4: [], 5217 h5: [], 5218 h6: [], 5219 i: [], 5220 img: ['src', 'alt', 'title', 'width', 'height'], 5221 li: [], 5222 ol: [], 5223 p: [], 5224 pre: [], 5225 s: [], 5226 small: [], 5227 span: [], 5228 sub: [], 5229 sup: [], 5230 strong: [], 5231 u: [], 5232 ul: [] 5233 /** 5234 * A pattern that recognizes a commonly useful subset of URLs that are safe. 5235 * 5236 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts 5237 */ 5238 5239 }; 5240 var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi; 5241 /** 5242 * A pattern that matches safe data URLs. Only matches image, video and audio types. 5243 * 5244 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts 5245 */ 5246 5247 var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i; 5248 5249 function allowedAttribute(attr, allowedAttributeList) { 5250 var attrName = attr.nodeName.toLowerCase(); 5251 5252 if (allowedAttributeList.indexOf(attrName) !== -1) { 5253 if (uriAttrs.indexOf(attrName) !== -1) { 5254 return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN)); 5255 } 5256 5257 return true; 5258 } 5259 5260 var regExp = allowedAttributeList.filter(function (attrRegex) {
5261 return attrRegex instanceof RegExp; 5262 }); // Check if a regular expression validates the attribute. 5263 5264 for (var i = 0, l = regExp.length; i < l; i++) { 5265 if (attrName.match(regExp[i])) { 5266 return true; 5267 } 5268 } 5269 5270 return false; 5271 } 5272 5273 function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) { 5274 if (unsafeHtml.length === 0) { 5275 return unsafeHtml; 5276 } 5277 5278 if (sanitizeFn && typeof sanitizeFn === 'function') { 5279 return sanitizeFn(unsafeHtml); 5280 } 5281 5282 var domParser = new window.DOMParser(); 5283 var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 5284 var whitelistKeys = Object.keys(whiteList); 5285 var elements = [].slice.call(createdDocument.body.querySelectorAll('*')); 5286 5287 var _loop = function _loop(i, len) { 5288 var el = elements[i]; 5289 var elName = el.nodeName.toLowerCase(); 5290 5291 if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) { 5292 el.parentNode.removeChild(el); 5293 return "continue"; 5294 } 5295 5296 var attributeList = [].slice.call(el.attributes); 5297 var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []); 5298 attributeList.forEach(function (attr) { 5299 if (!allowedAttribute(attr, whitelistedAttributes)) { 5300 el.removeAttribute(attr.nodeName); 5301 } 5302 }); 5303 }; 5304 5305 for (var i = 0, len = elements.length; i < len; i++) { 5306 var _ret = _loop(i, len); 5307 5308 if (_ret === "continue") continue; 5309 } 5310 5311 return createdDocument.body.innerHTML; 5312 } 5313 /** 5314 * ------------------------------------------------------------------------ 5315 * Constants 5316 * ------------------------------------------------------------------------ 5317 */ 5318 5319 5320 var NAME$6 = 'tooltip'; 5321 var VERSION$6 = '4.3.1'; 5322 var DATA_KEY$6 = 'bs.tooltip'; 5323 var EVENT_KEY$6 = "." + DATA_KEY$6; 5324 var JQUERY_NO_CONFLICT$6 = $.fn[NAME$6]; 5325 var CLASS_PREFIX = 'bs-tooltip'; 5326 var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); 5327 var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']; 5328 var DefaultType$4 = { 5329 animation: 'boolean', 5330 template: 'string', 5331 title: '(string|element|function)', 5332 trigger: 'string', 5333 delay: '(number|object)', 5334 html: 'boolean', 5335 selector: '(string|boolean)', 5336 placement: '(string|function)', 5337 offset: '(number|string|function)', 5338 container: '(string|element|boolean)', 5339 fallbackPlacement: '(string|array)', 5340 boundary: '(string|element)', 5341 sanitize: 'boolean', 5342 sanitizeFn: '(null|function)', 5343 whiteList: 'object' 5344 }; 5345 var AttachmentMap$1 = { 5346 AUTO: 'auto', 5347 TOP: 'top', 5348 RIGHT: 'right', 5349 BOTTOM: 'bottom', 5350 LEFT: 'left' 5351 }; 5352 var Default$4 = { 5353 animation: true, 5354 template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>', 5355 trigger: 'hover focus', 5356 title: '', 5357 delay: 0, 5358 html: false, 5359 selector: false, 5360 placement: 'top', 5361 offset: 0, 5362 container: false, 5363 fallbackPlacement: 'flip', 5364 boundary: 'scrollParent', 5365 sanitize: true, 5366 sanitizeFn: null, 5367 whiteList: DefaultWhitelist 5368 }; 5369 var HoverState = { 5370 SHOW: 'show', 5371 OUT: 'out' 5372 }; 5373 var Event$6 = { 5374 HIDE: "hide" + EVENT_KEY$6, 5375 HIDDEN: "hidden" + EVENT_KEY$6, 5376 SHOW: "show" + EVENT_KEY$6, 5377 SHOWN: "shown" + EVENT_KEY$6, 5378 INSERTED: "inserted" + EVENT_KEY$6, 5379 CLICK: "click" + EVENT_KEY$6, 5380 FOCUSIN: "focusin" + EVENT_KEY$6, 5381 FOCUSOUT: "focusout" + EVENT_KEY$6, 5382 MOUSEENTER: "mouseenter" + EVENT_KEY$6, 5383 MOUSELEAVE: "mouseleave" + EVENT_KEY$6 5384 }; 5385 var ClassName$6 = { 5386 FADE: 'fade', 5387 SHOW: 'show' 5388 }; 5389 var Selector$6 = { 5390 TOOLTIP: '.tooltip', 5391 TOOLTIP_INNER: '.tooltip-inner', 5392 ARROW: '.arrow' 5393 }; 5394 var Trigger = { 5395 HOVER: 'hover', 5396 FOCUS: 'focus', 5397 CLICK: 'click', 5398 MANUAL: 'manual' 5399 /** 5400 * ------------------------------------------------------------------------ 5401 * Class Definition 5402 * ------------------------------------------------------------------------ 5403 */ 5404 5405 }; 5406 5407 var Tooltip = 5408 /*#__PURE__*/ 5409 function () { 5410 function Tooltip(element, config) { 5411 /** 5412 * Check for Popper dependency 5413 * Popper - https://popper.js.org 5414 */ 5415 if (typeof Popper === 'undefined') { 5416 throw new TypeError('Bootstrap\'s tooltips require Popper.js (https://popper.js.org/)'); 5417 } // private 5418 5419 5420 this._isEnabled = true; 5421 this._timeout = 0; 5422 this._hoverState = ''; 5423 this._activeTrigger = {}; 5424 this._popper = null; // Protected 5425 5426 this.element = element; 5427 this.config = this._getConfig(config); 5428 this.tip = null; 5429 5430 this._setListeners(); 5431 } // Getters 5432 5433 5434 var _proto = Tooltip.prototype; // Public 5435 5436 _proto.enable = function enable() { 5437 this._isEnabled = true; 5438 }; 5439 5440 _proto.disable = function disable() { 5441 this._isEnabled = false;
5442 }; 5443 5444 _proto.toggleEnabled = function toggleEnabled() { 5445 this._isEnabled = !this._isEnabled; 5446 }; 5447 5448 _proto.toggle = function toggle(event) { 5449 if (!this._isEnabled) { 5450 return; 5451 } 5452 5453 if (event) { 5454 var dataKey = this.constructor.DATA_KEY; 5455 var context = $(event.currentTarget).data(dataKey); 5456 5457 if (!context) { 5458 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 5459 $(event.currentTarget).data(dataKey, context); 5460 } 5461 5462 context._activeTrigger.click = !context._activeTrigger.click; 5463 5464 if (context._isWithActiveTrigger()) { 5465 context._enter(null, context); 5466 } else { 5467 context._leave(null, context); 5468 } 5469 } else { 5470 if ($(this.getTipElement()).hasClass(ClassName$6.SHOW)) { 5471 this._leave(null, this); 5472 5473 return; 5474 } 5475 5476 this._enter(null, this); 5477 } 5478 }; 5479 5480 _proto.dispose = function dispose() { 5481 clearTimeout(this._timeout); 5482 $.removeData(this.element, this.constructor.DATA_KEY); 5483 $(this.element).off(this.constructor.EVENT_KEY); 5484 $(this.element).closest('.modal').off('hide.bs.modal'); 5485 5486 if (this.tip) { 5487 $(this.tip).remove(); 5488 } 5489 5490 this._isEnabled = null; 5491 this._timeout = null; 5492 this._hoverState = null; 5493 this._activeTrigger = null; 5494 5495 if (this._popper !== null) { 5496 this._popper.destroy(); 5497 } 5498 5499 this._popper = null; 5500 this.element = null; 5501 this.config = null; 5502 this.tip = null; 5503 }; 5504 5505 _proto.show = function show() { 5506 var _this = this; 5507 5508 if ($(this.element).css('display') === 'none') { 5509 throw new Error('Please use show on visible elements'); 5510 } 5511 5512 var showEvent = $.Event(this.constructor.Event.SHOW); 5513 5514 if (this.isWithContent() && this._isEnabled) { 5515 $(this.element).trigger(showEvent); 5516 var shadowRoot = Util.findShadowRoot(this.element); 5517 var isInTheDom = $.contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element); 5518 5519 if (showEvent.isDefaultPrevented() || !isInTheDom) { 5520 return; 5521 } 5522 5523 var tip = this.getTipElement(); 5524 var tipId = Util.getUID(this.constructor.NAME);
5525 tip.setAttribute('id', tipId); 5526 this.element.setAttribute('aria-describedby', tipId); 5527 this.setContent(); 5528 5529 if (this.config.animation) { 5530 $(tip).addClass(ClassName$6.FADE); 5531 } 5532 5533 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; 5534 5535 var attachment = this._getAttachment(placement); 5536 5537 this.addAttachmentClass(attachment); 5538 5539 var container = this._getContainer(); 5540 5541 $(tip).data(this.constructor.DATA_KEY, this); 5542 5543 if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) { 5544 $(tip).appendTo(container); 5545 } 5546 5547 $(this.element).trigger(this.constructor.Event.INSERTED); 5548 this._popper = new Popper(this.element, tip, { 5549 placement: attachment, 5550 modifiers: { 5551 offset: this._getOffset(), 5552 flip: { 5553 behavior: this.config.fallbackPlacement 5554 }, 5555 arrow: { 5556 element: Selector$6.ARROW 5557 }, 5558 preventOverflow: { 5559 boundariesElement: this.config.boundary 5560 } 5561 }, 5562 onCreate: function onCreate(data) { 5563 if (data.originalPlacement !== data.placement) { 5564 _this._handlePopperPlacementChange(data); 5565 } 5566 }, 5567 onUpdate: function onUpdate(data) { 5568 return _this._handlePopperPlacementChange(data); 5569 } 5570 }); 5571 $(tip).addClass(ClassName$6.SHOW); // If this is a touch-enabled device we add extra 5572 // empty mouseover listeners to the body's immediate children; 5573 // only needed because of broken event delegation on iOS 5574 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 5575 5576 if ('ontouchstart' in document.documentElement) { 5577 $(document.body).children().on('mouseover', null, $.noop); 5578 } 5579 5580 var complete = function complete() { 5581 if (_this.config.animation) { 5582 _this._fixTransition(); 5583 } 5584 5585 var prevHoverState = _this._hoverState; 5586 _this._hoverState = null; 5587 $(_this.element).trigger(_this.constructor.Event.SHOWN); 5588 5589 if (prevHoverState === HoverState.OUT) { 5590 _this._leave(null, _this); 5591 } 5592 }; 5593 5594 if ($(this.tip).hasClass(ClassName$6.FADE)) { 5595 var transitionDuration = Util.getTransitionDurationFromElement(this.tip); 5596 $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 5597 } else { 5598 complete(); 5599 } 5600 } 5601 }; 5602 5603 _proto.hide = function hide(callback) { 5604 var _this2 = this; 5605 5606 var tip = this.getTipElement(); 5607 var hideEvent = $.Event(this.constructor.Event.HIDE); 5608 5609 var complete = function complete() { 5610 if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) { 5611 tip.parentNode.removeChild(tip); 5612 } 5613 5614 _this2._cleanTipClass(); 5615 5616 _this2.element.removeAttribute('aria-describedby'); 5617 5618 $(_this2.element).trigger(_this2.constructor.Event.HIDDEN); 5619 5620 if (_this2._popper !== null) { 5621 _this2._popper.destroy(); 5622 } 5623 5624 if (callback) { 5625 callback(); 5626 } 5627 }; 5628 5629 $(this.element).trigger(hideEvent); 5630 5631 if (hideEvent.isDefaultPrevented()) { 5632 return; 5633 } 5634 5635 $(tip).removeClass(ClassName$6.SHOW); // If this is a touch-enabled device we remove the extra 5636 // empty mouseover listeners we added for iOS support 5637 5638 if ('ontouchstart' in document.documentElement) { 5639 $(document.body).children().off('mouseover', null, $.noop); 5640 } 5641 5642 this._activeTrigger[Trigger.CLICK] = false; 5643 this._activeTrigger[Trigger.FOCUS] = false; 5644 this._activeTrigger[Trigger.HOVER] = false; 5645 5646 if ($(this.tip).hasClass(ClassName$6.FADE)) { 5647 var transitionDuration = Util.getTransitionDurationFromElement(tip); 5648 $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 5649 } else { 5650 complete(); 5651 } 5652 5653 this._hoverState = ''; 5654 }; 5655
5656 _proto.update = function update() { 5657 if (this._popper !== null) { 5658 this._popper.scheduleUpdate(); 5659 } 5660 } // Protected 5661 ; 5662 5663 _proto.isWithContent = function isWithContent() { 5664 return Boolean(this.getTitle()); 5665 }; 5666 5667 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 5668 $(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment); 5669 }; 5670 5671 _proto.getTipElement = function getTipElement() { 5672 this.tip = this.tip || $(this.config.template)[0]; 5673 return this.tip; 5674 }; 5675 5676 _proto.setContent = function setContent() { 5677 var tip = this.getTipElement(); 5678 this.setElementContent($(tip.querySelectorAll(Selector$6.TOOLTIP_INNER)), this.getTitle()); 5679 $(tip).removeClass(ClassName$6.FADE + " " + ClassName$6.SHOW); 5680 }; 5681 5682 _proto.setElementContent = function setElementContent($element, content) { 5683 if (typeof content === 'object' && (content.nodeType || content.jquery)) { 5684 // Content is a DOM node or a jQuery 5685 if (this.config.html) { 5686 if (!$(content).parent().is($element)) { 5687 $element.empty().append(content); 5688 } 5689 } else { 5690 $element.text($(content).text()); 5691 } 5692 5693 return; 5694 } 5695 5696 if (this.config.html) { 5697 if (this.config.sanitize) { 5698 content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn); 5699 } 5700 5701 $element.html(content); 5702 } else { 5703 $element.text(content); 5704 } 5705 }; 5706 5707 _proto.getTitle = function getTitle() { 5708 var title = this.element.getAttribute('data-original-title'); 5709 5710 if (!title) { 5711 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; 5712 } 5713 5714 return title; 5715 } // Private 5716 ; 5717 5718 _proto._getOffset = function _getOffset() { 5719 var _this3 = this; 5720 5721 var offset = {}; 5722 5723 if (typeof this.config.offset === 'function') { 5724 offset.fn = function (data) { 5725 data.offsets = _objectSpread({}, data.offsets, _this3.config.offset(data.offsets, _this3.element) || {}); 5726 return data; 5727 }; 5728 } else { 5729 offset.offset = this.config.offset; 5730 } 5731 5732 return offset; 5733 }; 5734 5735 _proto._getContainer = function _getContainer() { 5736 if (this.config.container === false) { 5737 return document.body; 5738 } 5739 5740 if (Util.isElement(this.config.container)) { 5741 return $(this.config.container); 5742 } 5743 5744 return $(document).find(this.config.container); 5745 }; 5746 5747 _proto._getAttachment = function _getAttachment(placement) { 5748 return AttachmentMap$1[placement.toUpperCase()]; 5749 }; 5750 5751 _proto._setListeners = function _setListeners() { 5752 var _this4 = this; 5753 5754 var triggers = this.config.trigger.split(' '); 5755 triggers.forEach(function (trigger) { 5756 if (trigger === 'click') { 5757 $(_this4.element).on(_this4.constructor.Event.CLICK, _this4.config.selector, function (event) { 5758 return _this4.toggle(event); 5759 }); 5760 } else if (trigger !== Trigger.MANUAL) { 5761 var eventIn = trigger === Trigger.HOVER ? _this4.constructor.Event.MOUSEENTER : _this4.constructor.Event.FOCUSIN; 5762 var eventOut = trigger === Trigger.HOVER ? _this4.constructor.Event.MOUSELEAVE : _this4.constructor.Event.FOCUSOUT; 5763 $(_this4.element).on(eventIn, _this4.config.selector, function (event) { 5764 return _this4._enter(event); 5765 }).on(eventOut, _this4.config.selector, function (event) { 5766 return _this4._leave(event); 5767 }); 5768 } 5769 }); 5770 $(this.element).closest('.modal').on('hide.bs.modal', function () { 5771 if (_this4.element) { 5772 _this4.hide(); 5773 } 5774 }); 5775 5776 if (this.config.selector) { 5777 this.config = _objectSpread({}, this.config, { 5778 trigger: 'manual', 5779 selector: '' 5780 }); 5781 } else { 5782 this._fixTitle(); 5783 } 5784 }; 5785 5786 _proto._fixTitle = function _fixTitle() { 5787 var titleType = typeof this.element.getAttribute('data-original-title'); 5788 5789 if (this.element.getAttribute('title') || titleType !== 'string') { 5790 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); 5791 this.element.setAttribute('title', ''); 5792 } 5793 }; 5794 5795 _proto._enter = function _enter(event, context) { 5796 var dataKey = this.constructor.DATA_KEY; 5797 context = context || $(event.currentTarget).data(dataKey); 5798 5799 if (!context) { 5800 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 5801 $(event.currentTarget).data(dataKey, context); 5802 } 5803 5804 if (event) { 5805 context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true; 5806 } 5807 5808 if ($(context.getTipElement()).hasClass(ClassName$6.SHOW) || context._hoverState === HoverState.SHOW) { 5809 context._hoverState = HoverState.SHOW; 5810 return; 5811 } 5812 5813 clearTimeout(context._timeout); 5814 context._hoverState = HoverState.SHOW; 5815 5816 if (!context.config.delay || !context.config.delay.show) { 5817 context.show(); 5818 return; 5819 } 5820 5821 context._timeout = setTimeout(function () { 5822 if (context._hoverState === HoverState.SHOW) { 5823 context.show(); 5824 } 5825 }, context.config.delay.show); 5826 }; 5827 5828 _proto._leave = function _leave(event, context) { 5829 var dataKey = this.constructor.DATA_KEY; 5830 context = context || $(event.currentTarget).data(dataKey); 5831 5832 if (!context) { 5833 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 5834 $(event.currentTarget).data(dataKey, context); 5835 } 5836 5837 if (event) { 5838 context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
5839 } 5840 5841 if (context._isWithActiveTrigger()) { 5842 return; 5843 } 5844 5845 clearTimeout(context._timeout); 5846 context._hoverState = HoverState.OUT; 5847 5848 if (!context.config.delay || !context.config.delay.hide) { 5849 context.hide(); 5850 return; 5851 } 5852 5853 context._timeout = setTimeout(function () { 5854 if (context._hoverState === HoverState.OUT) { 5855 context.hide(); 5856 } 5857 }, context.config.delay.hide); 5858 }; 5859 5860 _proto._isWithActiveTrigger = function _isWithActiveTrigger() { 5861 for (var trigger in this._activeTrigger) { 5862 if (this._activeTrigger[trigger]) { 5863 return true; 5864 } 5865 } 5866 5867 return false; 5868 }; 5869 5870 _proto._getConfig = function _getConfig(config) { 5871 var dataAttributes = $(this.element).data(); 5872 Object.keys(dataAttributes).forEach(function (dataAttr) { 5873 if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) { 5874 delete dataAttributes[dataAttr]; 5875 } 5876 }); 5877 config = _objectSpread({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {}); 5878 5879 if (typeof config.delay === 'number') { 5880 config.delay = { 5881 show: config.delay, 5882 hide: config.delay 5883 }; 5884 } 5885 5886 if (typeof config.title === 'number') { 5887 config.title = config.title.toString(); 5888 } 5889 5890 if (typeof config.content === 'number') { 5891 config.content = config.content.toString(); 5892 } 5893 5894 Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType); 5895 5896 if (config.sanitize) { 5897 config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn); 5898 } 5899 5900 return config; 5901 }; 5902 5903 _proto._getDelegateConfig = function _getDelegateConfig() { 5904 var config = {}; 5905 5906 if (this.config) { 5907 for (var key in this.config) { 5908 if (this.constructor.Default[key] !== this.config[key]) { 5909 config[key] = this.config[key]; 5910 } 5911 } 5912 } 5913 5914 return config; 5915 }; 5916 5917 _proto._cleanTipClass = function _cleanTipClass() { 5918 var $tip = $(this.getTipElement()); 5919 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX); 5920 5921 if (tabClass !== null && tabClass.length) { 5922 $tip.removeClass(tabClass.join('')); 5923 } 5924 }; 5925 5926 _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { 5927 var popperInstance = popperData.instance; 5928 this.tip = popperInstance.popper; 5929 5930 this._cleanTipClass(); 5931 5932 this.addAttachmentClass(this._getAttachment(popperData.placement)); 5933 }; 5934 5935 _proto._fixTransition = function _fixTransition() { 5936 var tip = this.getTipElement(); 5937 var initConfigAnimation = this.config.animation; 5938 5939 if (tip.getAttribute('x-placement') !== null) { 5940 return; 5941 } 5942 5943 $(tip).removeClass(ClassName$6.FADE); 5944 this.config.animation = false; 5945 this.hide(); 5946 this.show(); 5947 this.config.animation = initConfigAnimation; 5948 } // Static 5949 ; 5950 5951 Tooltip._jQueryInterface = function _jQueryInterface(config) { 5952 return this.each(function () { 5953 var data = $(this).data(DATA_KEY$6); 5954 5955 var _config = typeof config === 'object' && config; 5956 5957 if (!data && /dispose|hide/.test(config)) { 5958 return; 5959 } 5960 5961 if (!data) { 5962 data = new Tooltip(this, _config); 5963 $(this).data(DATA_KEY$6, data); 5964 } 5965 5966 if (typeof config === 'string') { 5967 if (typeof data[config] === 'undefined') { 5968 throw new TypeError("No method named \"" + config + "\""); 5969 } 5970 5971 data[config](); 5972 } 5973 }); 5974 }; 5975 5976 _createClass(Tooltip, null, [{ 5977 key: "VERSION", 5978 get: function get() { 5979 return VERSION$6; 5980 } 5981 }, { 5982 key: "Default", 5983 get: function get() { 5984 return Default$4; 5985 } 5986 }, { 5987 key: "NAME", 5988 get: function get() { 5989 return NAME$6; 5990 } 5991 }, { 5992 key: "DATA_KEY", 5993 get: function get() { 5994 return DATA_KEY$6; 5995 } 5996 }, { 5997 key: "Event", 5998 get: function get() { 5999 return Event$6; 6000 } 6001 }, {
6002 key: "EVENT_KEY", 6003 get: function get() { 6004 return EVENT_KEY$6; 6005 } 6006 }, { 6007 key: "DefaultType", 6008 get: function get() { 6009 return DefaultType$4; 6010 } 6011 }]); 6012 6013 return Tooltip; 6014 }(); 6015 /** 6016 * ------------------------------------------------------------------------ 6017 * jQuery 6018 * ------------------------------------------------------------------------ 6019 */ 6020 6021 6022 $.fn[NAME$6] = Tooltip._jQueryInterface; 6023 $.fn[NAME$6].Constructor = Tooltip; 6024 6025 $.fn[NAME$6].noConflict = function () { 6026 $.fn[NAME$6] = JQUERY_NO_CONFLICT$6; 6027 return Tooltip._jQueryInterface; 6028 }; 6029 /** 6030 * ------------------------------------------------------------------------ 6031 * Constants 6032 * ------------------------------------------------------------------------ 6033 */ 6034 6035 6036 var NAME$7 = 'popover'; 6037 var VERSION$7 = '4.3.1'; 6038 var DATA_KEY$7 = 'bs.popover'; 6039 var EVENT_KEY$7 = "." + DATA_KEY$7; 6040 var JQUERY_NO_CONFLICT$7 = $.fn[NAME$7]; 6041 var CLASS_PREFIX$1 = 'bs-popover'; 6042 var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g'); 6043 6044 var Default$5 = _objectSpread({}, Tooltip.Default, { 6045 placement: 'right', 6046 trigger: 'click', 6047 content: '', 6048 template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>' 6049 }); 6050 6051 var DefaultType$5 = _objectSpread({}, Tooltip.DefaultType, { 6052 content: '(string|element|function)' 6053 }); 6054 6055 var ClassName$7 = { 6056 FADE: 'fade', 6057 SHOW: 'show' 6058 }; 6059 var Selector$7 = { 6060 TITLE: '.popover-header', 6061 CONTENT: '.popover-body' 6062 }; 6063 var Event$7 = { 6064 HIDE: "hide" + EVENT_KEY$7, 6065 HIDDEN: "hidden" + EVENT_KEY$7, 6066 SHOW: "show" + EVENT_KEY$7, 6067 SHOWN: "shown" + EVENT_KEY$7, 6068 INSERTED: "inserted" + EVENT_KEY$7, 6069 CLICK: "click" + EVENT_KEY$7, 6070 FOCUSIN: "focusin" + EVENT_KEY$7, 6071 FOCUSOUT: "focusout" + EVENT_KEY$7, 6072 MOUSEENTER: "mouseenter" + EVENT_KEY$7, 6073 MOUSELEAVE: "mouseleave" + EVENT_KEY$7 6074 /** 6075 * ------------------------------------------------------------------------ 6076 * Class Definition 6077 * ------------------------------------------------------------------------ 6078 */ 6079 6080 }; 6081 6082 var Popover = 6083 /*#__PURE__*/ 6084 function (_Tooltip) { 6085 _inheritsLoose(Popover, _Tooltip); 6086 6087 function Popover() { 6088 return _Tooltip.apply(this, arguments) || this; 6089 } 6090 6091 var _proto = Popover.prototype; // Overrides 6092 6093 _proto.isWithContent = function isWithContent() { 6094 return this.getTitle() || this._getContent(); 6095 }; 6096 6097 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 6098 $(this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment); 6099 }; 6100 6101 _proto.getTipElement = function getTipElement() { 6102 this.tip = this.tip || $(this.config.template)[0]; 6103 return this.tip; 6104 }; 6105 6106 _proto.setContent = function setContent() { 6107 var $tip = $(this.getTipElement()); // We use append for html objects to maintain js events 6108 6109 this.setElementContent($tip.find(Selector$7.TITLE), this.getTitle()); 6110 6111 var content = this._getContent(); 6112 6113 if (typeof content === 'function') { 6114 content = content.call(this.element); 6115 } 6116 6117 this.setElementContent($tip.find(Selector$7.CONTENT), content); 6118 $tip.removeClass(ClassName$7.FADE + " " + ClassName$7.SHOW); 6119 } // Private 6120 ; 6121 6122 _proto._getContent = function _getContent() { 6123 return this.element.getAttribute('data-content') || this.config.content; 6124 }; 6125 6126 _proto._cleanTipClass = function _cleanTipClass() { 6127 var $tip = $(this.getTipElement()); 6128 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1); 6129 6130 if (tabClass !== null && tabClass.length > 0) { 6131 $tip.removeClass(tabClass.join('')); 6132 } 6133 } // Static 6134 ; 6135 6136 Popover._jQueryInterface = function _jQueryInterface(config) { 6137 return this.each(function () { 6138 var data = $(this).data(DATA_KEY$7); 6139 6140 var _config = typeof config === 'object' ? config : null; 6141 6142 if (!data && /dispose|hide/.test(config)) { 6143 return; 6144 } 6145 6146 if (!data) { 6147 data = new Popover(this, _config); 6148 $(this).data(DATA_KEY$7, data); 6149 } 6150 6151 if (typeof config === 'string') { 6152 if (typeof data[config] === 'undefined') {
6153 throw new TypeError("No method named \"" + config + "\""); 6154 } 6155 6156 data[config](); 6157 } 6158 }); 6159 }; 6160 6161 _createClass(Popover, null, [{ 6162 key: "VERSION", 6163 // Getters 6164 get: function get() { 6165 return VERSION$7; 6166 } 6167 }, { 6168 key: "Default", 6169 get: function get() { 6170 return Default$5; 6171 } 6172 }, { 6173 key: "NAME", 6174 get: function get() { 6175 return NAME$7; 6176 } 6177 }, { 6178 key: "DATA_KEY", 6179 get: function get() { 6180 return DATA_KEY$7; 6181 } 6182 }, { 6183 key: "Event", 6184 get: function get() { 6185 return Event$7; 6186 } 6187 }, { 6188 key: "EVENT_KEY", 6189 get: function get() { 6190 return EVENT_KEY$7; 6191 } 6192 }, { 6193 key: "DefaultType", 6194 get: function get() { 6195 return DefaultType$5; 6196 } 6197 }]); 6198 6199 return Popover; 6200 }(Tooltip); 6201 /** 6202 * ------------------------------------------------------------------------ 6203 * jQuery 6204 * ------------------------------------------------------------------------ 6205 */ 6206 6207 6208 $.fn[NAME$7] = Popover._jQueryInterface; 6209 $.fn[NAME$7].Constructor = Popover; 6210 6211 $.fn[NAME$7].noConflict = function () { 6212 $.fn[NAME$7] = JQUERY_NO_CONFLICT$7; 6213 return Popover._jQueryInterface; 6214 }; 6215 /** 6216 * ------------------------------------------------------------------------ 6217 * Constants 6218 * ------------------------------------------------------------------------ 6219 */ 6220 6221 6222 var NAME$8 = 'scrollspy'; 6223 var VERSION$8 = '4.3.1'; 6224 var DATA_KEY$8 = 'bs.scrollspy'; 6225 var EVENT_KEY$8 = "." + DATA_KEY$8; 6226 var DATA_API_KEY$6 = '.data-api'; 6227 var JQUERY_NO_CONFLICT$8 = $.fn[NAME$8]; 6228 var Default$6 = { 6229 offset: 10, 6230 method: 'auto', 6231 target: '' 6232 }; 6233 var DefaultType$6 = { 6234 offset: 'number', 6235 method: 'string', 6236 target: '(string|element)' 6237 }; 6238 var Event$8 = { 6239 ACTIVATE: "activate" + EVENT_KEY$8, 6240 SCROLL: "scroll" + EVENT_KEY$8, 6241 LOAD_DATA_API: "load" + EVENT_KEY$8 + DATA_API_KEY$6 6242 }; 6243 var ClassName$8 = { 6244 DROPDOWN_ITEM: 'dropdown-item', 6245 DROPDOWN_MENU: 'dropdown-menu', 6246 ACTIVE: 'active' 6247 }; 6248 var Selector$8 = { 6249 DATA_SPY: '[data-spy="scroll"]', 6250 ACTIVE: '.active', 6251 NAV_LIST_GROUP: '.nav, .list-group', 6252 NAV_LINKS: '.nav-link', 6253 NAV_ITEMS: '.nav-item', 6254 LIST_ITEMS: '.list-group-item', 6255 DROPDOWN: '.dropdown', 6256 DROPDOWN_ITEMS: '.dropdown-item', 6257 DROPDOWN_TOGGLE: '.dropdown-toggle' 6258 }; 6259 var OffsetMethod = { 6260 OFFSET: 'offset', 6261 POSITION: 'position' 6262 /** 6263 * ------------------------------------------------------------------------ 6264 * Class Definition 6265 * ------------------------------------------------------------------------ 6266 */ 6267 6268 }; 6269 6270 var ScrollSpy = 6271 /*#__PURE__*/ 6272 function () { 6273 function ScrollSpy(element, config) { 6274 var _this = this; 6275 6276 this._element = element; 6277 this._scrollElement = element.tagName === 'BODY' ? window : element; 6278 this._config = this._getConfig(config); 6279 this._selector = this._config.target + " " + Selector$8.NAV_LINKS + "," + (this._config.target + " " + Selector$8.LIST_ITEMS + ",") + (this._config.target + " " + Selector$8.DROPDOWN_ITEMS); 6280 this._offsets = []; 6281 this._targets = []; 6282 this._activeTarget = null; 6283 this._scrollHeight = 0; 6284 $(this._scrollElement).on(Event$8.SCROLL, function (event) { 6285 return _this._process(event); 6286 }); 6287 this.refresh(); 6288 6289 this._process(); 6290 } // Getters 6291 6292 6293 var _proto = ScrollSpy.prototype; // Public 6294 6295 _proto.refresh = function refresh() { 6296 var _this2 = this; 6297 6298 var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION; 6299 var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; 6300 var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0; 6301 this._offsets = []; 6302 this._targets = []; 6303 this._scrollHeight = this._getScrollHeight(); 6304 var targets = [].slice.call(document.querySelectorAll(this._selector)); 6305 targets.map(function (element) { 6306 var target; 6307 var targetSelector = Util.getSelectorFromElement(element); 6308
6309 if (targetSelector) { 6310 target = document.querySelector(targetSelector); 6311 } 6312 6313 if (target) { 6314 var targetBCR = target.getBoundingClientRect(); 6315 6316 if (targetBCR.width || targetBCR.height) { 6317 // TODO (fat): remove sketch reliance on jQuery position/offset 6318 return [$(target)[offsetMethod]().top + offsetBase, targetSelector]; 6319 } 6320 } 6321 6322 return null; 6323 }).filter(function (item) { 6324 return item; 6325 }).sort(function (a, b) { 6326 return a[0] - b[0]; 6327 }).forEach(function (item) { 6328 _this2._offsets.push(item[0]); 6329 6330 _this2._targets.push(item[1]); 6331 }); 6332 }; 6333 6334 _proto.dispose = function dispose() { 6335 $.removeData(this._element, DATA_KEY$8); 6336 $(this._scrollElement).off(EVENT_KEY$8); 6337 this._element = null; 6338 this._scrollElement = null; 6339 this._config = null; 6340 this._selector = null; 6341 this._offsets = null; 6342 this._targets = null; 6343 this._activeTarget = null; 6344 this._scrollHeight = null; 6345 } // Private 6346 ; 6347 6348 _proto._getConfig = function _getConfig(config) { 6349 config = _objectSpread({}, Default$6, typeof config === 'object' && config ? config : {}); 6350 6351 if (typeof config.target !== 'string') { 6352 var id = $(config.target).attr('id'); 6353 6354 if (!id) { 6355 id = Util.getUID(NAME$8); 6356 $(config.target).attr('id', id); 6357 } 6358 6359 config.target = "#" + id; 6360 } 6361 6362 Util.typeCheckConfig(NAME$8, config, DefaultType$6); 6363 return config; 6364 }; 6365 6366 _proto._getScrollTop = function _getScrollTop() { 6367 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; 6368 }; 6369 6370 _proto._getScrollHeight = function _getScrollHeight() { 6371 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); 6372 }; 6373 6374 _proto._getOffsetHeight = function _getOffsetHeight() { 6375 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; 6376 }; 6377 6378 _proto._process = function _process() { 6379 var scrollTop = this._getScrollTop() + this._config.offset; 6380 6381 var scrollHeight = this._getScrollHeight(); 6382 6383 var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); 6384 6385 if (this._scrollHeight !== scrollHeight) { 6386 this.refresh(); 6387 } 6388 6389 if (scrollTop >= maxScroll) { 6390 var target = this._targets[this._targets.length - 1]; 6391 6392 if (this._activeTarget !== target) { 6393 this._activate(target); 6394 } 6395 6396 return; 6397 } 6398 6399 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) { 6400 this._activeTarget = null; 6401 6402 this._clear(); 6403 6404 return; 6405 } 6406 6407 var offsetLength = this._offsets.length; 6408 6409 for (var i = offsetLength; i--;) { 6410 var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); 6411 6412 if (isActiveTarget) { 6413 this._activate(this._targets[i]); 6414 } 6415 } 6416 }; 6417 6418 _proto._activate = function _activate(target) { 6419 this._activeTarget = target; 6420 6421 this._clear(); 6422 6423 var queries = this._selector.split(',').map(function (selector) { 6424 return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]"; 6425 }); 6426 6427 var $link = $([].slice.call(document.querySelectorAll(queries.join(',')))); 6428 6429 if ($link.hasClass(ClassName$8.DROPDOWN_ITEM)) { 6430 $link.closest(Selector$8.DROPDOWN).find(Selector$8.DROPDOWN_TOGGLE).addClass(ClassName$8.ACTIVE); 6431 $link.addClass(ClassName$8.ACTIVE); 6432 } else { 6433 // Set triggered link as active 6434 $link.addClass(ClassName$8.ACTIVE); // Set triggered links parents as active 6435 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 6436 6437 $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_LINKS + ", " + Selector$8.
6437LIST_ITEMS).addClass(ClassName$8.ACTIVE); // Handle special case when .nav-link is inside .nav-item 6438 6439 $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_ITEMS).children(Selector$8.NAV_LINKS).addClass(ClassName$8.ACTIVE); 6440 } 6441 6442 $(this._scrollElement).trigger(Event$8.ACTIVATE, { 6443 relatedTarget: target 6444 }); 6445 }; 6446 6447 _proto._clear = function _clear() { 6448 [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) { 6449 return node.classList.contains(ClassName$8.ACTIVE); 6450 }).forEach(function (node) { 6451 return node.classList.remove(ClassName$8.ACTIVE); 6452 }); 6453 } // Static 6454 ; 6455 6456 ScrollSpy._jQueryInterface = function _jQueryInterface(config) { 6457 return this.each(function () { 6458 var data = $(this).data(DATA_KEY$8); 6459 6460 var _config = typeof config === 'object' && config; 6461 6462 if (!data) { 6463 data = new ScrollSpy(this, _config); 6464 $(this).data(DATA_KEY$8, data); 6465 } 6466 6467 if (typeof config === 'string') { 6468 if (typeof data[config] === 'undefined') { 6469 throw new TypeError("No method named \"" + config + "\""); 6470 } 6471 6472 data[config](); 6473 } 6474 }); 6475 }; 6476 6477 _createClass(ScrollSpy, null, [{ 6478 key: "VERSION", 6479 get: function get() { 6480 return VERSION$8; 6481 } 6482 }, { 6483 key: "Default", 6484 get: function get() { 6485 return Default$6; 6486 } 6487 }]); 6488 6489 return ScrollSpy; 6490 }(); 6491 /** 6492 * ------------------------------------------------------------------------ 6493 * Data Api implementation 6494 * ------------------------------------------------------------------------ 6495 */ 6496 6497 6498 $(window).on(Event$8.LOAD_DATA_API, function () { 6499 var scrollSpys = [].slice.call(document.querySelectorAll(Selector$8.DATA_SPY)); 6500 var scrollSpysLength = scrollSpys.length; 6501 6502 for (var i = scrollSpysLength; i--;) { 6503 var $spy = $(scrollSpys[i]); 6504 6505 ScrollSpy._jQueryInterface.call($spy, $spy.data()); 6506 } 6507 }); 6508 /** 6509 * ------------------------------------------------------------------------ 6510 * jQuery 6511 * ------------------------------------------------------------------------ 6512 */ 6513 6514 $.fn[NAME$8] = ScrollSpy._jQueryInterface; 6515 $.fn[NAME$8].Constructor = ScrollSpy; 6516 6517 $.fn[NAME$8].noConflict = function () { 6518 $.fn[NAME$8] = JQUERY_NO_CONFLICT$8; 6519 return ScrollSpy._jQueryInterface; 6520 }; 6521 /** 6522 * ------------------------------------------------------------------------ 6523 * Constants 6524 * ------------------------------------------------------------------------ 6525 */ 6526 6527 6528 var NAME$9 = 'tab'; 6529 var VERSION$9 = '4.3.1'; 6530 var DATA_KEY$9 = 'bs.tab'; 6531 var EVENT_KEY$9 = "." + DATA_KEY$9; 6532 var DATA_API_KEY$7 = '.data-api'; 6533 var JQUERY_NO_CONFLICT$9 = $.fn[NAME$9]; 6534 var Event$9 = { 6535 HIDE: "hide" + EVENT_KEY$9, 6536 HIDDEN: "hidden" + EVENT_KEY$9, 6537 SHOW: "show" + EVENT_KEY$9, 6538 SHOWN: "shown" + EVENT_KEY$9, 6539 CLICK_DATA_API: "click" + EVENT_KEY$9 + DATA_API_KEY$7 6540 }; 6541 var ClassName$9 = { 6542 DROPDOWN_MENU: 'dropdown-menu', 6543 ACTIVE: 'active', 6544 DISABLED: 'disabled', 6545 FADE: 'fade', 6546 SHOW: 'show' 6547 }; 6548 var Selector$9 = { 6549 DROPDOWN: '.dropdown', 6550 NAV_LIST_GROUP: '.nav, .list-group', 6551 ACTIVE: '.active', 6552 ACTIVE_UL: '> li > .active', 6553 DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]', 6554 DROPDOWN_TOGGLE: '.dropdown-toggle', 6555 DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active' 6556 /** 6557 * ------------------------------------------------------------------------ 6558 * Class Definition 6559 * ------------------------------------------------------------------------ 6560 */ 6561 6562 }; 6563 6564 var Tab = 6565 /*#__PURE__*/ 6566 function () { 6567 function Tab(element) { 6568 this._element = element; 6569 } // Getters 6570 6571 6572 var _proto = Tab.prototype; // Public 6573 6574 _proto.show = function show() { 6575 var _this = this; 6576 6577 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $(this._element).hasClass(ClassName$9.ACTIVE) || $(this._element).hasClass(ClassName$9.DISABLED)) { 6578 return; 6579 } 6580 6581 var target; 6582 var previous; 6583 var listElement = $(this._element).closest(Selector$9.NAV_LIST_GROUP)[0]; 6584 var selector = Util.getSelectorFromElement(this._element); 6585 6586 if (listElement) { 6587 var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? Selector$9.ACTIVE_UL : Selector$9.ACTIVE; 6588 previous = $.makeArray($(listElement).find(itemSelector)); 6589 previous = previous[previous.length - 1]; 6590 } 6591 6592 var hideEvent = $.Event(Event$9.HIDE, { 6593 relatedTarget: this._element 6594 }); 6595 var showEvent = $.Event(Event$9.SHOW, { 6596 relatedTarget: previous 6597 }); 6598 6599 if (previous) { 6600 $(previous).trigger(hideEvent); 6601 } 6602 6603 $(this._element).trigger(showEvent); 6604 6605 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { 6606 return; 6607 } 6608 6609 if (selector) { 6610 target = document.querySelector(selector); 6611 } 6612 6613 this._activate(this._element, listElement); 6614 6615 var complete = function complete() { 6616 var hiddenEvent = $.Event(Event$9.HIDDEN, { 6617 relatedTarget: _this._element 6618 }); 6619 var shownEvent = $.Event(Event$9.SHOWN, { 6620 relatedTarget: previous 6621 }); 6622 $(previous).trigger(hiddenEvent); 6623 $(_this._element).trigger(shownEvent); 6624 }; 6625 6626 if (target) { 6627 this._activate(target, target.parentNode, complete); 6628 } else { 6629 complete(); 6630 } 6631 }; 6632 6633 _proto.dispose = function dispose() { 6634 $.removeData(this._element, DATA_KEY$9); 6635 this._element = null; 6636 } // Private 6637 ; 6638 6639 _proto._activate = function _activate(element, container, callback) { 6640 var _this2 = this; 6641 6642 var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $(container).find(Selector$9.ACTIVE_UL) : $(container).children(Selector$9.ACTIVE); 6643 var active = activeElements[0]; 6644 var isTransitioning = callback && active && $(active).hasClass(ClassName$9.FADE); 6645 6646 var complete = function complete() { 6647 return _this2._transitionComplete(element, active, callback); 6648 }; 6649 6650 if (active && isTransitioning) { 6651 var transitionDuration = Util.getTransitionDurationFromElement(active); 6652 $(active).removeClass(ClassName$9.SHOW).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 6653 } else { 6654 complete(); 6655 } 6656 }; 6657 6658 _proto._transitionComplete = function _transitionComplete(element, active, callback) { 6659 if (active) { 6660 $(active).removeClass(ClassName$9.ACTIVE);
6661 var dropdownChild = $(active.parentNode).find(Selector$9.DROPDOWN_ACTIVE_CHILD)[0]; 6662 6663 if (dropdownChild) { 6664 $(dropdownChild).removeClass(ClassName$9.ACTIVE); 6665 } 6666 6667 if (active.getAttribute('role') === 'tab') { 6668 active.setAttribute('aria-selected', false); 6669 } 6670 } 6671 6672 $(element).addClass(ClassName$9.ACTIVE); 6673 6674 if (element.getAttribute('role') === 'tab') { 6675 element.setAttribute('aria-selected', true); 6676 } 6677 6678 Util.reflow(element); 6679 6680 if (element.classList.contains(ClassName$9.FADE)) { 6681 element.classList.add(ClassName$9.SHOW); 6682 } 6683 6684 if (element.parentNode && $(element.parentNode).hasClass(ClassName$9.DROPDOWN_MENU)) { 6685 var dropdownElement = $(element).closest(Selector$9.DROPDOWN)[0]; 6686 6687 if (dropdownElement) { 6688 var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector$9.DROPDOWN_TOGGLE)); 6689 $(dropdownToggleList).addClass(ClassName$9.ACTIVE); 6690 } 6691 6692 element.setAttribute('aria-expanded', true); 6693 } 6694 6695 if (callback) { 6696 callback(); 6697 } 6698 } // Static 6699 ; 6700 6701 Tab._jQueryInterface = function _jQueryInterface(config) { 6702 return this.each(function () { 6703 var $this = $(this); 6704 var data = $this.data(DATA_KEY$9); 6705 6706 if (!data) { 6707 data = new Tab(this); 6708 $this.data(DATA_KEY$9, data); 6709 } 6710 6711 if (typeof config === 'string') { 6712 if (typeof data[config] === 'undefined') { 6713 throw new TypeError("No method named \"" + config + "\""); 6714 } 6715 6716 data[config](); 6717 } 6718 }); 6719 }; 6720 6721 _createClass(Tab, null, [{ 6722 key: "VERSION", 6723 get: function get() { 6724 return VERSION$9; 6725 } 6726 }]); 6727 6728 return Tab; 6729 }(); 6730 /** 6731 * ------------------------------------------------------------------------ 6732 * Data Api implementation 6733 * ------------------------------------------------------------------------ 6734 */ 6735 6736 6737 $(document).on(Event$9.CLICK_DATA_API, Selector$9.DATA_TOGGLE, function (event) { 6738 event.preventDefault(); 6739 6740 Tab._jQueryInterface.call($(this), 'show'); 6741 }); 6742 /** 6743 * ------------------------------------------------------------------------ 6744 * jQuery 6745 * ------------------------------------------------------------------------ 6746 */ 6747 6748 $.fn[NAME$9] = Tab._jQueryInterface; 6749 $.fn[NAME$9].Constructor = Tab; 6750 6751 $.fn[NAME$9].noConflict = function () { 6752 $.fn[NAME$9] = JQUERY_NO_CONFLICT$9; 6753 return Tab._jQueryInterface; 6754 }; 6755 /** 6756 * ------------------------------------------------------------------------ 6757 * Constants 6758 * ------------------------------------------------------------------------ 6759 */ 6760 6761 6762 var NAME$a = 'toast'; 6763 var VERSION$a = '4.3.1'; 6764 var DATA_KEY$a = 'bs.toast'; 6765 var EVENT_KEY$a = "." + DATA_KEY$a; 6766 var JQUERY_NO_CONFLICT$a = $.fn[NAME$a]; 6767 var Event$a = { 6768 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$a, 6769 HIDE: "hide" + EVENT_KEY$a, 6770 HIDDEN: "hidden" + EVENT_KEY$a, 6771 SHOW: "show" + EVENT_KEY$a, 6772 SHOWN: "shown" + EVENT_KEY$a 6773 }; 6774 var ClassName$a = { 6775 FADE: 'fade', 6776 HIDE: 'hide', 6777 SHOW: 'show', 6778 SHOWING: 'showing' 6779 }; 6780 var DefaultType$7 = { 6781 animation: 'boolean', 6782 autohide: 'boolean', 6783 delay: 'number' 6784 }; 6785 var Default$7 = { 6786 animation: true, 6787 autohide: true, 6788 delay: 500 6789 }; 6790 var Selector$a = { 6791 DATA_DISMISS: '[data-dismiss="toast"]' 6792 /** 6793 * ------------------------------------------------------------------------ 6794 * Class Definition 6795 * ------------------------------------------------------------------------ 6796 */ 6797 6798 }; 6799 6800 var Toast = 6801 /*#__PURE__*/ 6802 function () { 6803 function Toast(element, config) { 6804 this._element = element; 6805 this._config = this._getConfig(config); 6806 this._timeout = null; 6807 6808 this._setListeners(); 6809 } // Getters 6810 6811 6812 var _proto = Toast.prototype; // Public 6813 6814 _proto.show = function show() { 6815 var _this = this; 6816 6817 $(this._element).trigger(Event$a.SHOW); 6818 6819 if (this._config.animation) { 6820 this._element.classList.add(ClassName$a.FADE); 6821 } 6822 6823 var complete = function complete() { 6824 _this._element.classList.remove(ClassName$a.SHOWING); 6825 6826 _this._element.classList.add(ClassName$a.SHOW); 6827 6828 $(_this._element).trigger(Event$a.SHOWN); 6829 6830 if (_this._config.autohide) { 6831 _this.hide(); 6832 } 6833 }; 6834 6835 this._element.classList.remove(ClassName$a.HIDE); 6836 6837 this._element.classList.add(ClassName$a.SHOWING); 6838 6839 if (this._config.animation) { 6840 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 6841 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 6842 } else { 6843 complete(); 6844 } 6845 }; 6846 6847 _proto.hide = function hide(withoutTimeout) { 6848 var _this2 = this; 6849 6850 if (!this._element.classList.contains(ClassName$a.SHOW)) { 6851 return; 6852 } 6853 6854 $(this._element).trigger(Event$a.HIDE); 6855 6856 if (withoutTimeout) { 6857 this._close(); 6858 } else { 6859 this._timeout = setTimeout(function () { 6860 _this2._close(); 6861 }, this._config.delay); 6862 } 6863 }; 6864 6865 _proto.dispose = function dispose() { 6866 clearTimeout(this._timeout); 6867 this._timeout = null; 6868 6869 if (this._element.classList.contains(ClassName$a.SHOW)) { 6870 this._element.classList.remove(ClassName$a.SHOW); 6871 } 6872 6873 $(this._element).off(Event$a.CLICK_DISMISS); 6874 $.removeData(this._element, DATA_KEY$a); 6875 this._element = null; 6876 this._config = null; 6877 } // Private 6878 ; 6879 6880 _proto._getConfig = function _getConfig(config) { 6881 config = _objectSpread({}, Default$7, $(this._element).data(), typeof config === 'object' && config ? config : {}); 6882 Util.typeCheckConfig(NAME$a, config, this.constructor.DefaultType); 6883 return config; 6884 }; 6885 6886 _proto._setListeners = function _setListeners() { 6887 var _this3 = this; 6888 6889 $(this._element).on(Event$a.CLICK_DISMISS, Selector$a.DATA_DISMISS, function () { 6890 return _this3.hide(true); 6891 }); 6892 }; 6893 6894 _proto._close = function _close() { 6895 var _this4 = this; 6896 6897 var complete = function complete() { 6898 _this4._element.classList.add(ClassName$a.HIDE); 6899 6900 $(_this4._element).trigger(Event$a.HIDDEN); 6901 }; 6902 6903 this._element.classList.remove(ClassName$a.SHOW); 6904 6905 if (this._config.animation) { 6906 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 6907 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 6908 } else { 6909 complete(); 6910 } 6911 } // Static 6912 ; 6913 6914 Toast._jQueryInterface = function _jQueryInterface(config) { 6915 return this.each(function () { 6916 var $element = $(this); 6917 var data = $element.data(DATA_KEY$a); 6918 6919 var _config = typeof config === 'object' && config; 6920 6921 if (!data) { 6922 data = new Toast(this, _config); 6923 $element.data(DATA_KEY$a, data); 6924 } 6925 6926 if (typeof config === 'string') { 6927 if (typeof data[config] === 'undefined') {
6928 throw new TypeError("No method named \"" + config + "\""); 6929 } 6930 6931 data[config](this); 6932 } 6933 }); 6934 }; 6935 6936 _createClass(Toast, null, [{ 6937 key: "VERSION", 6938 get: function get() { 6939 return VERSION$a; 6940 } 6941 }, { 6942 key: "DefaultType", 6943 get: function get() { 6944 return DefaultType$7; 6945 } 6946 }, { 6947 key: "Default", 6948 get: function get() { 6949 return Default$7; 6950 } 6951 }]); 6952 6953 return Toast; 6954 }(); 6955 /** 6956 * ------------------------------------------------------------------------ 6957 * jQuery 6958 * ------------------------------------------------------------------------ 6959 */ 6960 6961 6962 $.fn[NAME$a] = Toast._jQueryInterface; 6963 $.fn[NAME$a].Constructor = Toast; 6964 6965 $.fn[NAME$a].noConflict = function () { 6966 $.fn[NAME$a] = JQUERY_NO_CONFLICT$a; 6967 return Toast._jQueryInterface; 6968 }; 6969 /** 6970 * -------------------------------------------------------------------------- 6971 * Bootstrap (v4.3.1): index.js 6972 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 6973 * -------------------------------------------------------------------------- 6974 */ 6975 6976 6977 (function () { 6978 if (typeof $ === 'undefined') { 6979 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); 6980 } 6981 6982 var version = $.fn.jquery.split(' ')[0].split('.'); 6983 var minMajor = 1; 6984 var ltMajor = 2; 6985 var minMinor = 9; 6986 var minPatch = 1; 6987 var maxMajor = 4; 6988 6989 if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) { 6990 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); 6991 } 6992 })(); 6993 6994 exports.Util = Util; 6995 exports.Alert = Alert; 6996 exports.Button = Button; 6997 exports.Carousel = Carousel; 6998 exports.Collapse = Collapse; 6999 exports.Dropdown = Dropdown; 7000 exports.Modal = Modal; 7001 exports.Popover = Popover; 7002 exports.Scrollspy = ScrollSpy; 7003 exports.Tab = Tab; 7004 exports.Toast = Toast; 7005 exports.Tooltip = Tooltip; 7006 Object.defineProperty(exports, '__esModule', { 7007 value: true 7008 }); 7009}); 7010/** 7011 * File skip-link-focus-fix.js. 7012 * 7013 * Helps with accessibility for keyboard only users. 7014 * 7015 * Learn more: https://git.io/vWdr2 7016 */ 7017(function () { 7018 var isWebkit = navigator.userAgent.toLowerCase().indexOf('webkit') > -1, 7019 isOpera = navigator.userAgent.toLowerCase().indexOf('opera') > -1, 7020 isIe = navigator.userAgent.toLowerCase().indexOf('msie') > -1; 7021 7022 if ((isWebkit || isOpera || isIe) && document.getElementById && window.addEventListener) { 7023 window.addEventListener('hashchange', function () { 7024 var id = location.hash.substring(1), 7025 element; 7026 7027 if (!/^[A-z0-9_-]+$/.test(id)) { 7028 return; 7029 } 7030 7031 element = document.getElementById(id); 7032 7033 if (element) { 7034 if (!/^(?:a|select|input|button|textarea)$/i.test(element.tagName)) { 7035 element.tabIndex = -1; 7036 } 7037 7038 element.focus(); 7039 } 7040 }, false); 7041 } 7042})(); 7043document.addEventListener("DOMContentLoaded", () => { 7044 const body = document.body; 7045 const menuMainId = document.getElementById("menu-site"); 7046 const menuOpenActive = document.getElementById("bg"); 7047 const menuPage = document.getElementById("menu-page"); 7048 const menuSearch = document.getElementById("menu-search"); 7049 const searchInput = document.getElementById("searchInput"); 7050 const btnSearchMenu = document.getElementById("btnSearchMenu"); 7051 7052 if (body.classList.contains("home")) { 7053 body.setAttribute('data-js', 'js-enabled'); 7054 } 7055 7056 const hasMenuButtonClassActive = function () { 7057 const buttonsMenu = document.querySelectorAll(".js-btn-menu"); 7058 let active = false; 7059 buttonsMenu.forEach(item => { 7060 if (item.classList.contains("btn__menu--active")) { 7061 active = true; 7062 } 7063 }); 7064 return active; 7065 }; 7066 7067 const removeButtonClassActive = function () { 7068 const activeMenuButton = document.querySelectorAll(".btn__menu--active"); 7069 activeMenuButton.forEach(button => { 7070 button.classList.remove("btn__menu--active"); 7071 }); 7072 }; 7073 7074 const AddToMenuClassSlide = function () { 7075 const menuOpen = document.querySelectorAll(".js-menu__dropdown-open");
7076 menuOpen.forEach(item => { 7077 item.classList.add("menu__dropdown--active-slide-hide"); 7078 }); 7079 }; 7080 7081 const removeMenuClass = function () { 7082 const menuOpen = document.querySelectorAll(".js-menu__dropdown-open"); 7083 menuOpen.forEach(item => { 7084 item.classList.remove("js-menu__dropdown-open"); 7085 item.classList.remove("menu__dropdown--scale"); 7086 item.classList.remove("menu__dropdown--active"); 7087 item.classList.remove("menu__dropdown--active-slide"); 7088 item.classList.remove("menu__dropdown--active-slide-hide"); 7089 }); 7090 }; 7091 7092 const addActiveClassBtnMenu = function (menuId, button) { 7093 button.classList.add("btn__menu--active"); 7094 menuId.classList.add("js-menu__dropdown-open"); 7095 }; 7096 7097 const addClassMenuOpen = function (menuId, button) { 7098 addActiveClassBtnMenu(menuId, button); 7099 body.classList.add("menu__open"); 7100 menuOpenActive.classList.add("menu__open-active"); 7101 menuId.classList.add("menu__dropdown--active-slide"); 7102 }; 7103 7104 const changeMenuOpen = function (menuId, button) { 7105 removeMenuClass(); 7106 addActiveClassBtnMenu(menuId, button); 7107 menuMainId.classList.add("menu__bg"); 7108 7109 if (menuPage.classList.contains("js-menu__dropdown-open")) { 7110 menuMainId.classList.add("menu__bg--height"); 7111 } else if (menuSearch.classList.contains("js-menu__dropdown-open")) { 7112 menuMainId.classList.add("menu__bg--height-search"); 7113 } else { 7114 menuMainId.classList.remove("menu__bg--height"); 7115 menuMainId.classList.remove("menu__bg--height-search"); 7116 } 7117 7118 menuId.classList.add("menu__dropdown--scale"); 7119 setTimeout(function () { 7120 menuId.classList.add("menu__dropdown--active"); 7121 }, 0.1); 7122 }; 7123 7124 const closeMenu = function () { 7125 AddToMenuClassSlide(); 7126 let timeRemove; 7127 7128 if (menuSearch.classList.contains("js-menu__dropdown-open")) { 7129 timeRemove = 10; 7130 } else { 7131 timeRemove = 310; 7132 } 7133 7134 setTimeout(function () { 7135 removeMenuClass(); 7136 }, timeRemove); 7137 removeButtonClassActive(); 7138 body.classList.remove("menu__open"); 7139 menuOpenActive.classList.remove("menu__open-active"); 7140 menuMainId.classList.remove("menu__bg"); 7141 }; 7142 7143 const activeMenu = function (button) { 7144 let menuId = button.getAttribute("data-menu-id"); 7145 menuId = document.getElementById(menuId); 7146 7147 if (!button.classList.contains("btn__menu--active")) { 7148 if (!hasMenuButtonClassActive()) { 7149 addClassMenuOpen(menuId, button); 7150 } else { 7151 removeButtonClassActive(); 7152 changeMenuOpen(menuId, button); 7153 } 7154 } else { 7155 closeMenu(); 7156 } 7157 }; 7158 7159 const buttonMenu = document.querySelectorAll(".js-btn-menu"); 7160 buttonMenu.forEach(button => { 7161 button.addEventListener("click", function () { 7162 activeMenu(button); 7163 }); 7164 }); 7165 const buttoMenuClose = document.querySelectorAll(".btn__close"); 7166 buttoMenuClose.forEach(btn => { 7167 btn.addEventListener("click", function () { 7168 closeMenu(); 7169 }); 7170 }); 7171 menuOpenActive.addEventListener("click", function () { 7172 closeMenu(); 7173 }); 7174 btnSearchMenu.addEventListener("click", function () { 7175 setTimeout(function () { 7176 searchInput.focus(); 7177 }, 300); 7178 }); 7179 const listUl = document.querySelectorAll("ul"); 7180 listUl.forEach(list => { 7181 const childListCount = list.childElementCount; 7182 7183 if (childListCount == 0) { 7184 list.remove(); 7185 } 7186 }); 7187 const buttonOpenSearch = document.getElementById("btnOpenSearch"); 7188 const buttonCloseSearch = document.getElementById("btnCloseSearch"); 7189 const formSearchDesktop = document.getElementById("formSearchDesktop"); 7190 const formSearchDesktopInput = document.getElementById("formSearchDesktopInput"); 7191 buttonOpenSearch.addEventListener("click", function () { 7192 buttonOpenSearch.classList.add("d-none"); 7193 formSearchDesktop.classList.remove("d-none"); 7194 formSearchDesktopInput.focus(); 7195 }); 7196 buttonCloseSearch.addEventListener("click", function () { 7197 buttonOpenSearch.classList.remove("d-none"); 7198 formSearchDesktop.classList.add("d-none"); 7199 }); 7200 const pingback = document.querySelector('.pingback'); 7201 7202 if (pingback) { 7203 pingback.remove(); 7204 } 7205 7206 if (body.classList.contains('single-post')) { 7207 const allLinks = document.querySelectorAll('.entry-content a, .comment-text a'); 7208 console.log(allLinks); 7209 allLinks.forEach(link => { 7210 const linkText = link.textContent; 7211 7212 if (link.childElementCount === 0) { 7213 link.innerHTML = `<span class='link--border'>${linkText}</span>`;
7214 } 7215 }); 7216 } 7217}); 7218} 7219 7220/* 7221 FILE ARCHIVED ON 08:05:40 Jun 24, 2026 AND RETRIEVED FROM THE 7222 INTERNET ARCHIVE ON 13:52:55 Aug 06, 2026. 7223 JAVASCRIPT APPENDED BY WAYBACK MACHINE, COPYRIGHT INTERNET ARCHIVE. 7224 7225 ALL OTHER CONTENT MAY ALSO BE PROTECTED BY COPYRIGHT (17 U.S.C. 7226 SECTION 108(a)(3)). 7227*/ 7228/* 7229playback timings (ms): 7230 capture_cache.get: 1.911 7231 load_resource: 111.334 (2) 7232 PetaboxLoader3.datanode: 62.1 (2) 7233 PetaboxLoader3.resolve: 47.168 7234*/
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.