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