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