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