1/*! 2 * Bootstrap v4.0.0-alpha.3 (http://getbootstrap.com) 3 * Copyright 2011-2016 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 4 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 5 */ 6 7if (typeof jQuery === 'undefined') { 8 throw new Error('Bootstrap\'s JavaScript requires jQuery') 9} 10 11+function ($) { 12 var version = $.fn.jquery.split(' ')[0].split('.') 13 if ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1) || (version[0] >= 4)) { 14 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0') 15 } 16}(jQuery); 17 18 19+function ($) { 20 21/** 22 * -------------------------------------------------------------------------- 23 * Bootstrap (v4.0.0-alpha.3): util.js 24 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 25 * -------------------------------------------------------------------------- 26 */ 27 28'use strict'; 29 30var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; 31 32var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); 33 34function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 35 36function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } 37 38var Util = (function ($) { 39 40 /** 41 * ------------------------------------------------------------------------ 42 * Private TransitionEnd Helpers 43 * ------------------------------------------------------------------------ 44 */ 45 46 var transition = false; 47 48 var MAX_UID = 1000000; 49 50 var TransitionEndEvent = { 51 WebkitTransition: 'webkitTransitionEnd', 52 MozTransition: 'transitionend', 53 OTransition: 'oTransitionEnd otransitionend', 54 transition: 'transitionend' 55 }; 56 57 // shoutout AngusCroll (https://goo.gl/pxwQGp) 58 function toType(obj) { 59 return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase(); 60 } 61 62 function isElement(obj) { 63 return (obj[0] || obj).nodeType; 64 } 65 66 function getSpecialTransitionEndEvent() { 67 return { 68 bindType: transition.end, 69 delegateType: transition.end, 70 handle: function handle(event) { 71 if ($(event.target).is(this)) { 72 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params 73 } 74 return undefined; 75 } 76 }; 77 } 78 79 function transitionEndTest() { 80 if (window.QUnit) { 81 return false; 82 } 83 84 var el = document.createElement('bootstrap'); 85 86 for (var _name in TransitionEndEvent) { 87 if (el.style[_name] !== undefined) { 88 return { end: TransitionEndEvent[_name] }; 89 } 90 } 91 92 return false;
93 } 94 95 function transitionEndEmulator(duration) { 96 var _this = this; 97 98 var called = false; 99 100 $(this).one(Util.TRANSITION_END, function () { 101 called = true; 102 }); 103 104 setTimeout(function () { 105 if (!called) { 106 Util.triggerTransitionEnd(_this); 107 } 108 }, duration); 109 110 return this; 111 } 112 113 function setTransitionEndSupport() { 114 transition = transitionEndTest(); 115 116 $.fn.emulateTransitionEnd = transitionEndEmulator; 117 118 if (Util.supportsTransitionEnd()) { 119 $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); 120 } 121 } 122 123 /** 124 * -------------------------------------------------------------------------- 125 * Public Util Api 126 * -------------------------------------------------------------------------- 127 */ 128 129 var Util = { 130 131 TRANSITION_END: 'bsTransitionEnd', 132 133 getUID: function getUID(prefix) { 134 do { 135 /* eslint-disable no-bitwise */ 136 prefix += ~ ~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here 137 /* eslint-enable no-bitwise */ 138 } while (document.getElementById(prefix)); 139 return prefix; 140 }, 141 142 getSelectorFromElement: function getSelectorFromElement(element) { 143 var selector = element.getAttribute('data-target'); 144 145 if (!selector) { 146 selector = element.getAttribute('href') || ''; 147 selector = /^#[a-z]/i.test(selector) ? selector : null; 148 } 149 150 return selector; 151 }, 152 153 reflow: function reflow(element) { 154 new Function('bs', 'return bs')(element.offsetHeight); 155 }, 156 157 triggerTransitionEnd: function triggerTransitionEnd(element) { 158 $(element).trigger(transition.end); 159 }, 160 161 supportsTransitionEnd: function supportsTransitionEnd() { 162 return Boolean(transition); 163 }, 164 165 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { 166 for (var property in configTypes) { 167 if (configTypes.hasOwnProperty(property)) { 168 var expectedTypes = configTypes[property]; 169 var value = config[property]; 170 var valueType = undefined; 171 172 if (value && isElement(value)) { 173 valueType = 'element'; 174 } else { 175 valueType = toType(value); 176 } 177 178 if (!new RegExp(expectedTypes).test(valueType)) { 179 throw new Error(componentName.toUpperCase() + ': ' + ('Option "' + property + '" provided type "' + valueType + '" ') + ('but expected type "' + expectedTypes + '".')); 180 } 181 } 182 } 183 } 184 }; 185 186 setTransitionEndSupport(); 187 188 return Util; 189})(jQuery); 190 191/** 192 * -------------------------------------------------------------------------- 193 * Bootstrap (v4.0.0-alpha.3): alert.js 194 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 195 * -------------------------------------------------------------------------- 196 */ 197 198var Alert = (function ($) { 199 200 /** 201 * ------------------------------------------------------------------------ 202 * Constants 203 * ------------------------------------------------------------------------ 204 */ 205 206 var NAME = 'alert'; 207 var VERSION = '4.0.0-alpha.3'; 208 var DATA_KEY = 'bs.alert'; 209 var EVENT_KEY = '.' + DATA_KEY; 210 var DATA_API_KEY = '.data-api'; 211 var JQUERY_NO_CONFLICT = $.fn[NAME]; 212 var TRANSITION_DURATION = 150; 213 214 var Selector = { 215 DISMISS: '[data-dismiss="alert"]' 216 }; 217 218 var Event = { 219 CLOSE: 'close' + EVENT_KEY, 220 CLOSED: 'closed' + EVENT_KEY, 221 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY 222 }; 223 224 var ClassName = { 225 ALERT: 'alert', 226 FADE: 'fade', 227 IN: 'in' 228 }; 229 230 /** 231 * ------------------------------------------------------------------------ 232 * Class Definition 233 * ------------------------------------------------------------------------ 234 */ 235 236 var Alert = (function () { 237 function Alert(element) { 238 _classCallCheck(this, Alert); 239 240 this._element = element; 241 } 242 243 /** 244 * ------------------------------------------------------------------------ 245 * Data Api implementation 246 * ------------------------------------------------------------------------ 247 */ 248 249 // getters 250 251 _createClass(Alert, [{ 252 key: 'close', 253 254 // public 255 256 value: function close(element) { 257 element = element || this._element; 258 259 var rootElement = this._getRootElement(element); 260 var customEvent = this._triggerCloseEvent(rootElement); 261 262 if (customEvent.isDefaultPrevented()) { 263 return; 264 } 265 266 this._removeElement(rootElement); 267 } 268 }, {
269 key: 'dispose', 270 value: function dispose() { 271 $.removeData(this._element, DATA_KEY); 272 this._element = null; 273 } 274 275 // private 276 277 }, { 278 key: '_getRootElement', 279 value: function _getRootElement(element) { 280 var selector = Util.getSelectorFromElement(element); 281 var parent = false; 282 283 if (selector) { 284 parent = $(selector)[0]; 285 } 286 287 if (!parent) { 288 parent = $(element).closest('.' + ClassName.ALERT)[0]; 289 } 290 291 return parent; 292 } 293 }, { 294 key: '_triggerCloseEvent', 295 value: function _triggerCloseEvent(element) { 296 var closeEvent = $.Event(Event.CLOSE); 297 298 $(element).trigger(closeEvent); 299 return closeEvent; 300 } 301 }, { 302 key: '_removeElement', 303 value: function _removeElement(element) { 304 $(element).removeClass(ClassName.IN); 305 306 if (!Util.supportsTransitionEnd() || !$(element).hasClass(ClassName.FADE)) { 307 this._destroyElement(element); 308 return; 309 } 310 311 $(element).one(Util.TRANSITION_END, $.proxy(this._destroyElement, this, element)).emulateTransitionEnd(TRANSITION_DURATION); 312 } 313 }, { 314 key: '_destroyElement', 315 value: function _destroyElement(element) { 316 $(element).detach().trigger(Event.CLOSED).remove(); 317 } 318 319 // static 320 321 }], [{ 322 key: '_jQueryInterface', 323 value: function _jQueryInterface(config) { 324 return this.each(function () { 325 var $element = $(this); 326 var data = $element.data(DATA_KEY); 327 328 if (!data) { 329 data = new Alert(this); 330 $element.data(DATA_KEY, data); 331 } 332 333 if (config === 'close') { 334 data[config](this); 335 } 336 }); 337 } 338 }, { 339 key: '_handleDismiss', 340 value: function _handleDismiss(alertInstance) { 341 return function (event) { 342 if (event) { 343 event.preventDefault(); 344 } 345 346 alertInstance.close(this); 347 }; 348 } 349 }, { 350 key: 'VERSION', 351 get: function get() { 352 return VERSION; 353 } 354 }]); 355 356 return Alert; 357 })(); 358 359 $(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert())); 360 361 /** 362 * ------------------------------------------------------------------------ 363 * jQuery 364 * ------------------------------------------------------------------------ 365 */ 366 367 $.fn[NAME] = Alert._jQueryInterface; 368 $.fn[NAME].Constructor = Alert; 369 $.fn[NAME].noConflict = function () { 370 $.fn[NAME] = JQUERY_NO_CONFLICT; 371 return Alert._jQueryInterface; 372 }; 373 374 return Alert; 375})(jQuery); 376 377/** 378 * -------------------------------------------------------------------------- 379 * Bootstrap (v4.0.0-alpha.3): button.js 380 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 381 * -------------------------------------------------------------------------- 382 */ 383 384var Button = (function ($) { 385 386 /** 387 * ------------------------------------------------------------------------ 388 * Constants 389 * ------------------------------------------------------------------------ 390 */ 391 392 var NAME = 'button'; 393 var VERSION = '4.0.0-alpha.3'; 394 var DATA_KEY = 'bs.button'; 395 var EVENT_KEY = '.' + DATA_KEY; 396 var DATA_API_KEY = '.data-api'; 397 var JQUERY_NO_CONFLICT = $.fn[NAME]; 398 399 var ClassName = { 400 ACTIVE: 'active', 401 BUTTON: 'btn', 402 FOCUS: 'focus' 403 }; 404 405 var Selector = { 406 DATA_TOGGLE_CARROT: '[data-toggle^="button"]', 407 DATA_TOGGLE: '[data-toggle="buttons"]', 408 INPUT: 'input', 409 ACTIVE: '.active', 410 BUTTON: '.btn' 411 }; 412 413 var Event = { 414 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY, 415 FOCUS_BLUR_DATA_API: 'focus' + EVENT_KEY + DATA_API_KEY + ' ' + ('blur' + EVENT_KEY + DATA_API_KEY) 416 }; 417 418 /** 419 * ------------------------------------------------------------------------ 420 * Class Definition 421 * ------------------------------------------------------------------------ 422 */ 423 424 var Button = (function () { 425 function Button(element) { 426 _classCallCheck(this, Button); 427 428 this._element = element; 429 } 430 431 /** 432 * ------------------------------------------------------------------------ 433 * Data Api implementation 434 * ------------------------------------------------------------------------ 435 */ 436 437 // getters 438 439 _createClass(Button, [{ 440 key: 'toggle', 441 442 // public 443
444 value: function toggle() { 445 var triggerChangeEvent = true; 446 var rootElement = $(this._element).closest(Selector.DATA_TOGGLE)[0]; 447 448 if (rootElement) { 449 var input = $(this._element).find(Selector.INPUT)[0]; 450 451 if (input) { 452 if (input.type === 'radio') { 453 if (input.checked && $(this._element).hasClass(ClassName.ACTIVE)) { 454 triggerChangeEvent = false; 455 } else { 456 var activeElement = $(rootElement).find(Selector.ACTIVE)[0]; 457 458 if (activeElement) { 459 $(activeElement).removeClass(ClassName.ACTIVE); 460 } 461 } 462 } 463 464 if (triggerChangeEvent) { 465 input.checked = !$(this._element).hasClass(ClassName.ACTIVE); 466 $(this._element).trigger('change'); 467 } 468 469 input.focus(); 470 } 471 } else { 472 this._element.setAttribute('aria-pressed', !$(this._element).hasClass(ClassName.ACTIVE)); 473 } 474 475 if (triggerChangeEvent) { 476 $(this._element).toggleClass(ClassName.ACTIVE); 477 } 478 } 479 }, { 480 key: 'dispose', 481 value: function dispose() { 482 $.removeData(this._element, DATA_KEY); 483 this._element = null; 484 } 485 486 // static 487 488 }], [{ 489 key: '_jQueryInterface', 490 value: function _jQueryInterface(config) { 491 return this.each(function () { 492 var data = $(this).data(DATA_KEY); 493 494 if (!data) { 495 data = new Button(this); 496 $(this).data(DATA_KEY, data); 497 } 498 499 if (config === 'toggle') { 500 data[config](); 501 } 502 }); 503 } 504 }, { 505 key: 'VERSION', 506 get: function get() { 507 return VERSION; 508 } 509 }]); 510 511 return Button; 512 })(); 513 514 $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) { 515 event.preventDefault(); 516 517 var button = event.target; 518 519 if (!$(button).hasClass(ClassName.BUTTON)) { 520 button = $(button).closest(Selector.BUTTON); 521 } 522 523 Button._jQueryInterface.call($(button), 'toggle'); 524 }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) { 525 var button = $(event.target).closest(Selector.BUTTON)[0]; 526 $(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type)); 527 }); 528 529 /** 530 * ------------------------------------------------------------------------ 531 * jQuery 532 * ------------------------------------------------------------------------ 533 */ 534 535 $.fn[NAME] = Button._jQueryInterface; 536 $.fn[NAME].Constructor = Button; 537 $.fn[NAME].noConflict = function () { 538 $.fn[NAME] = JQUERY_NO_CONFLICT; 539 return Button._jQueryInterface; 540 }; 541 542 return Button; 543})(jQuery); 544 545/** 546 * -------------------------------------------------------------------------- 547 * Bootstrap (v4.0.0-alpha.3): carousel.js 548 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 549 * -------------------------------------------------------------------------- 550 */ 551 552var Carousel = (function ($) { 553 554 /** 555 * ------------------------------------------------------------------------ 556 * Constants 557 * ------------------------------------------------------------------------ 558 */ 559 560 var NAME = 'carousel'; 561 var VERSION = '4.0.0-alpha.3'; 562 var DATA_KEY = 'bs.carousel'; 563 var EVENT_KEY = '.' + DATA_KEY; 564 var DATA_API_KEY = '.data-api'; 565 var JQUERY_NO_CONFLICT = $.fn[NAME]; 566 var TRANSITION_DURATION = 600; 567 var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key 568 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key 569 570 var Default = { 571 interval: 5000, 572 keyboard: true, 573 slide: false, 574 pause: 'hover', 575 wrap: true 576 }; 577 578 var DefaultType = { 579 interval: '(number|boolean)', 580 keyboard: 'boolean', 581 slide: '(boolean|string)', 582 pause: '(string|boolean)', 583 wrap: 'boolean' 584 }; 585 586 var Direction = { 587 NEXT: 'next', 588 PREVIOUS: 'prev' 589 }; 590 591 var Event = { 592 SLIDE: 'slide' + EVENT_KEY, 593 SLID: 'slid' + EVENT_KEY, 594 KEYDOWN: 'keydown' + EVENT_KEY, 595 MOUSEENTER: 'mouseenter' + EVENT_KEY, 596 MOUSELEAVE: 'mouseleave' + EVENT_KEY, 597 LOAD_DATA_API: 'load' + EVENT_KEY + DATA_API_KEY, 598 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY 599 }; 600 601 var ClassName = { 602 CAROUSEL: 'carousel', 603 ACTIVE: 'active', 604 SLIDE: 'slide', 605 RIGHT: 'right', 606 LEFT: 'left', 607 ITEM: 'carousel-item' 608 }; 609 610 var Selector = { 611 ACTIVE: '.active', 612 ACTIVE_ITEM: '.active.carousel-item', 613 ITEM: '.carousel-item', 614 NEXT_PREV: '.next, .prev', 615 INDICATORS: '.carousel-indicators',
616 DATA_SLIDE: '[data-slide], [data-slide-to]', 617 DATA_RIDE: '[data-ride="carousel"]' 618 }; 619 620 /** 621 * ------------------------------------------------------------------------ 622 * Class Definition 623 * ------------------------------------------------------------------------ 624 */ 625 626 var Carousel = (function () { 627 function Carousel(element, config) { 628 _classCallCheck(this, Carousel); 629 630 this._items = null; 631 this._interval = null; 632 this._activeElement = null; 633 634 this._isPaused = false; 635 this._isSliding = false; 636 637 this._config = this._getConfig(config); 638 this._element = $(element)[0]; 639 this._indicatorsElement = $(this._element).find(Selector.INDICATORS)[0]; 640 641 this._addEventListeners(); 642 } 643 644 /** 645 * ------------------------------------------------------------------------ 646 * Data Api implementation 647 * ------------------------------------------------------------------------ 648 */ 649 650 // getters 651 652 _createClass(Carousel, [{ 653 key: 'next', 654 655 // public 656 657 value: function next() { 658 if (!this._isSliding) { 659 this._slide(Direction.NEXT); 660 } 661 } 662 }, { 663 key: 'nextWhenVisible', 664 value: function nextWhenVisible() { 665 // Don't call next when the page isn't visible 666 if (!document.hidden) { 667 this.next(); 668 } 669 } 670 }, { 671 key: 'prev', 672 value: function prev() { 673 if (!this._isSliding) { 674 this._slide(Direction.PREVIOUS); 675 } 676 } 677 }, { 678 key: 'pause', 679 value: function pause(event) { 680 if (!event) { 681 this._isPaused = true; 682 } 683 684 if ($(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) { 685 Util.triggerTransitionEnd(this._element); 686 this.cycle(true); 687 } 688 689 clearInterval(this._interval); 690 this._interval = null; 691 } 692 }, { 693 key: 'cycle', 694 value: function cycle(event) { 695 if (!event) { 696 this._isPaused = false; 697 } 698 699 if (this._interval) { 700 clearInterval(this._interval); 701 this._interval = null; 702 } 703 704 if (this._config.interval && !this._isPaused) { 705 this._interval = setInterval($.proxy(document.visibilityState ? this.nextWhenVisible : this.next, this), this._config.interval); 706 } 707 } 708 }, { 709 key: 'to', 710 value: function to(index) { 711 var _this2 = this; 712 713 this._activeElement = $(this._element).find(Selector.ACTIVE_ITEM)[0]; 714 715 var activeIndex = this._getItemIndex(this._activeElement); 716 717 if (index > this._items.length - 1 || index < 0) { 718 return; 719 } 720 721 if (this._isSliding) { 722 $(this._element).one(Event.SLID, function () { 723 return _this2.to(index); 724 }); 725 return; 726 } 727 728 if (activeIndex === index) { 729 this.pause(); 730 this.cycle(); 731 return; 732 } 733 734 var direction = index > activeIndex ? Direction.NEXT : Direction.PREVIOUS; 735 736 this._slide(direction, this._items[index]); 737 } 738 }, { 739 key: 'dispose', 740 value: function dispose() { 741 $(this._element).off(EVENT_KEY); 742 $.removeData(this._element, DATA_KEY); 743 744 this._items = null; 745 this._config = null; 746 this._element = null; 747 this._interval = null; 748 this._isPaused = null; 749 this._isSliding = null; 750 this._activeElement = null; 751 this._indicatorsElement = null; 752 } 753 754 // private 755 756 }, { 757 key: '_getConfig', 758 value: function _getConfig(config) { 759 config = $.extend({}, Default, config); 760 Util.typeCheckConfig(NAME, config, DefaultType); 761 return config; 762 } 763 }, { 764 key: '_addEventListeners', 765 value: function _addEventListeners() { 766 if (this._config.keyboard) { 767 $(this._element).on(Event.KEYDOWN, $.proxy(this._keydown, this)); 768 } 769 770 if (this._config.pause === 'hover' && !('ontouchstart' in document.documentElement)) { 771 $(this._element).on(Event.MOUSEENTER, $.proxy(this.pause, this)).on(Event.MOUSELEAVE, $.proxy(this.cycle, this)); 772 } 773 } 774 }, {
775 key: '_keydown', 776 value: function _keydown(event) { 777 event.preventDefault(); 778 779 if (/input|textarea/i.test(event.target.tagName)) { 780 return; 781 } 782 783 switch (event.which) { 784 case ARROW_LEFT_KEYCODE: 785 this.prev(); 786 break; 787 case ARROW_RIGHT_KEYCODE: 788 this.next(); 789 break; 790 default: 791 return; 792 } 793 } 794 }, { 795 key: '_getItemIndex', 796 value: function _getItemIndex(element) { 797 this._items = $.makeArray($(element).parent().find(Selector.ITEM)); 798 return this._items.indexOf(element); 799 } 800 }, { 801 key: '_getItemByDirection', 802 value: function _getItemByDirection(direction, activeElement) { 803 var isNextDirection = direction === Direction.NEXT; 804 var isPrevDirection = direction === Direction.PREVIOUS; 805 var activeIndex = this._getItemIndex(activeElement); 806 var lastItemIndex = this._items.length - 1; 807 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; 808 809 if (isGoingToWrap && !this._config.wrap) { 810 return activeElement; 811 } 812 813 var delta = direction === Direction.PREVIOUS ? -1 : 1; 814 var itemIndex = (activeIndex + delta) % this._items.length; 815 816 return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex]; 817 } 818 }, { 819 key: '_triggerSlideEvent', 820 value: function _triggerSlideEvent(relatedTarget, directionalClassname) { 821 var slideEvent = $.Event(Event.SLIDE, { 822 relatedTarget: relatedTarget, 823 direction: directionalClassname 824 }); 825 826 $(this._element).trigger(slideEvent); 827 828 return slideEvent; 829 } 830 }, { 831 key: '_setActiveIndicatorElement', 832 value: function _setActiveIndicatorElement(element) { 833 if (this._indicatorsElement) { 834 $(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE); 835 836 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)]; 837 838 if (nextIndicator) { 839 $(nextIndicator).addClass(ClassName.ACTIVE); 840 } 841 } 842 } 843 }, { 844 key: '_slide', 845 value: function _slide(direction, element) { 846 var _this3 = this; 847 848 var activeElement = $(this._element).find(Selector.ACTIVE_ITEM)[0]; 849 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); 850 851 var isCycling = Boolean(this._interval); 852 853 var directionalClassName = direction === Direction.NEXT ? ClassName.LEFT : ClassName.RIGHT; 854 855 if (nextElement && $(nextElement).hasClass(ClassName.ACTIVE)) { 856 this._isSliding = false; 857 return; 858 } 859 860 var slideEvent = this._triggerSlideEvent(nextElement, directionalClassName); 861 if (slideEvent.isDefaultPrevented()) { 862 return; 863 } 864 865 if (!activeElement || !nextElement) { 866 // some weirdness is happening, so we bail 867 return; 868 } 869 870 this._isSliding = true; 871 872 if (isCycling) { 873 this.pause(); 874 } 875 876 this._setActiveIndicatorElement(nextElement); 877 878 var slidEvent = $.Event(Event.SLID, { 879 relatedTarget: nextElement, 880 direction: directionalClassName 881 }); 882 883 if (Util.supportsTransitionEnd() && $(this._element).hasClass(ClassName.SLIDE)) { 884 885 $(nextElement).addClass(direction); 886 887 Util.reflow(nextElement); 888 889 $(activeElement).addClass(directionalClassName); 890 $(nextElement).addClass(directionalClassName); 891 892 $(activeElement).one(Util.TRANSITION_END, function () { 893 $(nextElement).removeClass(directionalClassName).removeClass(direction); 894 895 $(nextElement).addClass(ClassName.ACTIVE); 896 897 $(activeElement).removeClass(ClassName.ACTIVE).removeClass(direction).removeClass(directionalClassName); 898 899 _this3._isSliding = false; 900 901 setTimeout(function () { 902 return $(_this3._element).trigger(slidEvent); 903 }, 0); 904 }).emulateTransitionEnd(TRANSITION_DURATION); 905 } else { 906 $(activeElement).removeClass(ClassName.ACTIVE); 907 $(nextElement).addClass(ClassName.ACTIVE); 908 909 this._isSliding = false;
910 $(this._element).trigger(slidEvent); 911 } 912 913 if (isCycling) { 914 this.cycle(); 915 } 916 } 917 918 // static 919 920 }], [{ 921 key: '_jQueryInterface', 922 value: function _jQueryInterface(config) { 923 return this.each(function () { 924 var data = $(this).data(DATA_KEY); 925 var _config = $.extend({}, Default, $(this).data()); 926 927 if (typeof config === 'object') { 928 $.extend(_config, config); 929 } 930 931 var action = typeof config === 'string' ? config : _config.slide; 932 933 if (!data) { 934 data = new Carousel(this, _config); 935 $(this).data(DATA_KEY, data); 936 } 937 938 if (typeof config === 'number') { 939 data.to(config); 940 } else if (typeof action === 'string') { 941 if (data[action] === undefined) { 942 throw new Error('No method named "' + action + '"'); 943 } 944 data[action](); 945 } else if (_config.interval) { 946 data.pause(); 947 data.cycle(); 948 } 949 }); 950 } 951 }, { 952 key: '_dataApiClickHandler', 953 value: function _dataApiClickHandler(event) { 954 var selector = Util.getSelectorFromElement(this); 955 956 if (!selector) { 957 return; 958 } 959 960 var target = $(selector)[0]; 961 962 if (!target || !$(target).hasClass(ClassName.CAROUSEL)) { 963 return; 964 } 965 966 var config = $.extend({}, $(target).data(), $(this).data()); 967 var slideIndex = this.getAttribute('data-slide-to'); 968 969 if (slideIndex) { 970 config.interval = false; 971 } 972 973 Carousel._jQueryInterface.call($(target), config); 974 975 if (slideIndex) { 976 $(target).data(DATA_KEY).to(slideIndex); 977 } 978 979 event.preventDefault(); 980 } 981 }, { 982 key: 'VERSION', 983 get: function get() { 984 return VERSION; 985 } 986 }, { 987 key: 'Default', 988 get: function get() { 989 return Default; 990 } 991 }]); 992 993 return Carousel; 994 })(); 995 996 $(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler); 997 998 $(window).on(Event.LOAD_DATA_API, function () { 999 $(Selector.DATA_RIDE).each(function () { 1000 var $carousel = $(this); 1001 Carousel._jQueryInterface.call($carousel, $carousel.data()); 1002 }); 1003 }); 1004 1005 /** 1006 * ------------------------------------------------------------------------ 1007 * jQuery 1008 * ------------------------------------------------------------------------ 1009 */ 1010 1011 $.fn[NAME] = Carousel._jQueryInterface; 1012 $.fn[NAME].Constructor = Carousel; 1013 $.fn[NAME].noConflict = function () { 1014 $.fn[NAME] = JQUERY_NO_CONFLICT; 1015 return Carousel._jQueryInterface; 1016 }; 1017 1018 return Carousel; 1019})(jQuery); 1020 1021/** 1022 * -------------------------------------------------------------------------- 1023 * Bootstrap (v4.0.0-alpha.3): collapse.js 1024 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 1025 * -------------------------------------------------------------------------- 1026 */ 1027 1028var Collapse = (function ($) { 1029 1030 /** 1031 * ------------------------------------------------------------------------ 1032 * Constants 1033 * ------------------------------------------------------------------------ 1034 */ 1035 1036 var NAME = 'collapse'; 1037 var VERSION = '4.0.0-alpha.3'; 1038 var DATA_KEY = 'bs.collapse'; 1039 var EVENT_KEY = '.' + DATA_KEY; 1040 var DATA_API_KEY = '.data-api'; 1041 var JQUERY_NO_CONFLICT = $.fn[NAME]; 1042 var TRANSITION_DURATION = 600; 1043 1044 var Default = { 1045 toggle: true, 1046 parent: '' 1047 }; 1048 1049 var DefaultType = { 1050 toggle: 'boolean', 1051 parent: 'string' 1052 }; 1053 1054 var Event = { 1055 SHOW: 'show' + EVENT_KEY, 1056 SHOWN: 'shown' + EVENT_KEY, 1057 HIDE: 'hide' + EVENT_KEY, 1058 HIDDEN: 'hidden' + EVENT_KEY, 1059 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY 1060 }; 1061 1062 var ClassName = { 1063 IN: 'in', 1064 COLLAPSE: 'collapse', 1065 COLLAPSING: 'collapsing', 1066 COLLAPSED: 'collapsed' 1067 }; 1068 1069 var Dimension = { 1070 WIDTH: 'width', 1071 HEIGHT: 'height' 1072 }; 1073 1074 var Selector = { 1075 ACTIVES: '.panel > .in, .panel > .collapsing', 1076 DATA_TOGGLE: '[data-toggle="collapse"]' 1077 }; 1078 1079 /** 1080 * ------------------------------------------------------------------------ 1081 * Class Definition 1082 * ------------------------------------------------------------------------ 1083 */ 1084 1085 var Collapse = (function () { 1086 function Collapse(element, config) { 1087 _classCallCheck(this, Collapse); 1088 1089 this._isTransitioning = false;
1090 this._element = element; 1091 this._config = this._getConfig(config); 1092 this._triggerArray = $.makeArray($('[data-toggle="collapse"][href="#' + element.id + '"],' + ('[data-toggle="collapse"][data-target="#' + element.id + '"]'))); 1093 1094 this._parent = this._config.parent ? this._getParent() : null; 1095 1096 if (!this._config.parent) { 1097 this._addAriaAndCollapsedClass(this._element, this._triggerArray); 1098 } 1099 1100 if (this._config.toggle) { 1101 this.toggle(); 1102 } 1103 } 1104 1105 /** 1106 * ------------------------------------------------------------------------ 1107 * Data Api implementation 1108 * ------------------------------------------------------------------------ 1109 */ 1110 1111 // getters 1112 1113 _createClass(Collapse, [{ 1114 key: 'toggle', 1115 1116 // public 1117 1118 value: function toggle() { 1119 if ($(this._element).hasClass(ClassName.IN)) { 1120 this.hide(); 1121 } else { 1122 this.show(); 1123 } 1124 } 1125 }, { 1126 key: 'show', 1127 value: function show() { 1128 var _this4 = this; 1129 1130 if (this._isTransitioning || $(this._element).hasClass(ClassName.IN)) { 1131 return; 1132 } 1133 1134 var actives = undefined; 1135 var activesData = undefined; 1136 1137 if (this._parent) { 1138 actives = $.makeArray($(Selector.ACTIVES)); 1139 if (!actives.length) { 1140 actives = null; 1141 } 1142 } 1143 1144 if (actives) { 1145 activesData = $(actives).data(DATA_KEY); 1146 if (activesData && activesData._isTransitioning) { 1147 return; 1148 } 1149 } 1150 1151 var startEvent = $.Event(Event.SHOW); 1152 $(this._element).trigger(startEvent); 1153 if (startEvent.isDefaultPrevented()) { 1154 return; 1155 } 1156 1157 if (actives) { 1158 Collapse._jQueryInterface.call($(actives), 'hide'); 1159 if (!activesData) { 1160 $(actives).data(DATA_KEY, null); 1161 } 1162 } 1163 1164 var dimension = this._getDimension(); 1165 1166 $(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING); 1167 1168 this._element.style[dimension] = 0; 1169 this._element.setAttribute('aria-expanded', true); 1170 1171 if (this._triggerArray.length) { 1172 $(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true); 1173 } 1174 1175 this.setTransitioning(true); 1176 1177 var complete = function complete() { 1178 $(_this4._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.IN); 1179 1180 _this4._element.style[dimension] = ''; 1181 1182 _this4.setTransitioning(false); 1183 1184 $(_this4._element).trigger(Event.SHOWN); 1185 }; 1186 1187 if (!Util.supportsTransitionEnd()) { 1188 complete(); 1189 return; 1190 } 1191 1192 var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 1193 var scrollSize = 'scroll' + capitalizedDimension; 1194 1195 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION); 1196 1197 this._element.style[dimension] = this._element[scrollSize] + 'px'; 1198 } 1199 }, { 1200 key: 'hide', 1201 value: function hide() { 1202 var _this5 = this; 1203 1204 if (this._isTransitioning || !$(this._element).hasClass(ClassName.IN)) { 1205 return; 1206 } 1207 1208 var startEvent = $.Event(Event.HIDE); 1209 $(this._element).trigger(startEvent); 1210 if (startEvent.isDefaultPrevented()) { 1211 return; 1212 } 1213 1214 var dimension = this._getDimension(); 1215 var offsetDimension = dimension === Dimension.WIDTH ? 'offsetWidth' : 'offsetHeight'; 1216 1217 this._element.style[dimension] = this._element[offsetDimension] + 'px'; 1218 1219 Util.reflow(this._element); 1220 1221 $(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.IN); 1222 1223 this._element.setAttribute('aria-expanded', false); 1224 1225 if (this._triggerArray.length) { 1226 $(this._triggerArray).addClass(ClassName.COLLAPSED).attr('aria-expanded', false); 1227 } 1228 1229 this.setTransitioning(true); 1230 1231 var complete = function complete() { 1232 _this5.setTransitioning(false); 1233 $(_this5._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN); 1234 }; 1235 1236 this._element.style[dimension] = 0; 1237 1238 if (!Util.supportsTransitionEnd()) { 1239 complete(); 1240 return; 1241 } 1242 1243 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION); 1244 } 1245 }, {
1246 key: 'setTransitioning', 1247 value: function setTransitioning(isTransitioning) { 1248 this._isTransitioning = isTransitioning; 1249 } 1250 }, { 1251 key: 'dispose', 1252 value: function dispose() { 1253 $.removeData(this._element, DATA_KEY); 1254 1255 this._config = null; 1256 this._parent = null; 1257 this._element = null; 1258 this._triggerArray = null; 1259 this._isTransitioning = null; 1260 } 1261 1262 // private 1263 1264 }, { 1265 key: '_getConfig', 1266 value: function _getConfig(config) { 1267 config = $.extend({}, Default, config); 1268 config.toggle = Boolean(config.toggle); // coerce string values 1269 Util.typeCheckConfig(NAME, config, DefaultType); 1270 return config; 1271 } 1272 }, { 1273 key: '_getDimension', 1274 value: function _getDimension() { 1275 var hasWidth = $(this._element).hasClass(Dimension.WIDTH); 1276 return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT; 1277 } 1278 }, { 1279 key: '_getParent', 1280 value: function _getParent() { 1281 var _this6 = this; 1282 1283 var parent = $(this._config.parent)[0]; 1284 var selector = '[data-toggle="collapse"][data-parent="' + this._config.parent + '"]'; 1285 1286 $(parent).find(selector).each(function (i, element) { 1287 _this6._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]); 1288 }); 1289 1290 return parent; 1291 } 1292 }, { 1293 key: '_addAriaAndCollapsedClass', 1294 value: function _addAriaAndCollapsedClass(element, triggerArray) { 1295 if (element) { 1296 var isOpen = $(element).hasClass(ClassName.IN); 1297 element.setAttribute('aria-expanded', isOpen); 1298 1299 if (triggerArray.length) { 1300 $(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen); 1301 } 1302 } 1303 } 1304 1305 // static 1306 1307 }], [{ 1308 key: '_getTargetFromElement', 1309 value: function _getTargetFromElement(element) { 1310 var selector = Util.getSelectorFromElement(element); 1311 return selector ? $(selector)[0] : null; 1312 } 1313 }, { 1314 key: '_jQueryInterface', 1315 value: function _jQueryInterface(config) { 1316 return this.each(function () { 1317 var $this = $(this); 1318 var data = $this.data(DATA_KEY); 1319 var _config = $.extend({}, Default, $this.data(), typeof config === 'object' && config); 1320 1321 if (!data && _config.toggle && /show|hide/.test(config)) { 1322 _config.toggle = false; 1323 } 1324 1325 if (!data) { 1326 data = new Collapse(this, _config); 1327 $this.data(DATA_KEY, data); 1328 } 1329 1330 if (typeof config === 'string') { 1331 if (data[config] === undefined) { 1332 throw new Error('No method named "' + config + '"'); 1333 } 1334 data[config](); 1335 } 1336 }); 1337 } 1338 }, { 1339 key: 'VERSION', 1340 get: function get() { 1341 return VERSION; 1342 } 1343 }, { 1344 key: 'Default', 1345 get: function get() { 1346 return Default; 1347 } 1348 }]); 1349 1350 return Collapse; 1351 })(); 1352 1353 $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) { 1354 event.preventDefault(); 1355 1356 var target = Collapse._getTargetFromElement(this); 1357 var data = $(target).data(DATA_KEY); 1358 var config = data ? 'toggle' : $(this).data(); 1359 1360 Collapse._jQueryInterface.call($(target), config); 1361 }); 1362 1363 /** 1364 * ------------------------------------------------------------------------ 1365 * jQuery 1366 * ------------------------------------------------------------------------ 1367 */ 1368 1369 $.fn[NAME] = Collapse._jQueryInterface; 1370 $.fn[NAME].Constructor = Collapse; 1371 $.fn[NAME].noConflict = function () { 1372 $.fn[NAME] = JQUERY_NO_CONFLICT; 1373 return Collapse._jQueryInterface; 1374 }; 1375 1376 return Collapse; 1377})(jQuery); 1378 1379/** 1380 * -------------------------------------------------------------------------- 1381 * Bootstrap (v4.0.0-alpha.3): dropdown.js 1382 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 1383 * -------------------------------------------------------------------------- 1384 */ 1385 1386var Dropdown = (function ($) { 1387 1388 /** 1389 * ------------------------------------------------------------------------ 1390 * Constants 1391 * ------------------------------------------------------------------------ 1392 */ 1393 1394 var NAME = 'dropdown'; 1395 var VERSION = '4.0.0-alpha.3'; 1396 var DATA_KEY = 'bs.dropdown'; 1397 var EVENT_KEY = '.' + DATA_KEY; 1398 var DATA_API_KEY = '.data-api'; 1399 var JQUERY_NO_CONFLICT = $.fn[NAME]; 1400 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 1401 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key 1402 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key 1403 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) 1404 1405 var Event = { 1406 HIDE: 'hide' + EVENT_KEY, 1407 HIDDEN: 'hidden' + EVENT_KEY, 1408 SHOW: 'show' + EVENT_KEY, 1409 SHOWN: 'shown' + EVENT_KEY, 1410 CLICK: 'click' + EVENT_KEY, 1411 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY, 1412 KEYDOWN_DATA_API: 'keydown' + EVENT_KEY + DATA_API_KEY 1413 }; 1414 1415 var ClassName = { 1416 BACKDROP: 'dropdown-backdrop', 1417 DISABLED: 'disabled', 1418 OPEN: 'open' 1419 }; 1420 1421 var Selector = { 1422 BACKDROP: '.dropdown-backdrop', 1423 DATA_TOGGLE: '[data-toggle="dropdown"]', 1424 FORM_CHILD: '.dropdown form', 1425 ROLE_MENU: '[role="menu"]', 1426 ROLE_LISTBOX: '[role="listbox"]', 1427 NAVBAR_NAV: '.navbar-nav', 1428 VISIBLE_ITEMS: '[role="menu"] li:not(.disabled) a, ' + '[role="listbox"] li:not(.disabled) a' 1429 }; 1430 1431 /** 1432 * ------------------------------------------------------------------------ 1433 * Class Definition 1434 * ------------------------------------------------------------------------ 1435 */ 1436 1437 var Dropdown = (function () { 1438 function Dropdown(element) { 1439 _classCallCheck(this, Dropdown); 1440 1441 this._element = element; 1442 1443 this._addEventListeners(); 1444 } 1445 1446 /** 1447 * ------------------------------------------------------------------------ 1448 * Data Api implementation 1449 * ------------------------------------------------------------------------ 1450 */ 1451 1452 // getters 1453 1454 _createClass(Dropdown, [{ 1455 key: 'toggle', 1456 1457 // public 1458
1459 value: function toggle() { 1460 if (this.disabled || $(this).hasClass(ClassName.DISABLED)) { 1461 return false; 1462 } 1463 1464 var parent = Dropdown._getParentFromElement(this); 1465 var isActive = $(parent).hasClass(ClassName.OPEN); 1466 1467 Dropdown._clearMenus(); 1468 1469 if (isActive) { 1470 return false; 1471 } 1472 1473 if ('ontouchstart' in document.documentElement && !$(parent).closest(Selector.NAVBAR_NAV).length) { 1474 1475 // if mobile we use a backdrop because click events don't delegate 1476 var dropdown = document.createElement('div'); 1477 dropdown.className = ClassName.BACKDROP; 1478 $(dropdown).insertBefore(this); 1479 $(dropdown).on('click', Dropdown._clearMenus); 1480 } 1481 1482 var relatedTarget = { relatedTarget: this }; 1483 var showEvent = $.Event(Event.SHOW, relatedTarget); 1484 1485 $(parent).trigger(showEvent); 1486 1487 if (showEvent.isDefaultPrevented()) { 1488 return false; 1489 } 1490 1491 this.focus(); 1492 this.setAttribute('aria-expanded', 'true'); 1493 1494 $(parent).toggleClass(ClassName.OPEN); 1495 $(parent).trigger($.Event(Event.SHOWN, relatedTarget)); 1496 1497 return false; 1498 } 1499 }, { 1500 key: 'dispose', 1501 value: function dispose() { 1502 $.removeData(this._element, DATA_KEY); 1503 $(this._element).off(EVENT_KEY); 1504 this._element = null; 1505 } 1506 1507 // private 1508 1509 }, { 1510 key: '_addEventListeners', 1511 value: function _addEventListeners() { 1512 $(this._element).on(Event.CLICK, this.toggle); 1513 } 1514 1515 // static 1516 1517 }], [{ 1518 key: '_jQueryInterface', 1519 value: function _jQueryInterface(config) { 1520 return this.each(function () { 1521 var data = $(this).data(DATA_KEY); 1522 1523 if (!data) { 1524 $(this).data(DATA_KEY, data = new Dropdown(this)); 1525 } 1526 1527 if (typeof config === 'string') { 1528 if (data[config] === undefined) { 1529 throw new Error('No method named "' + config + '"'); 1530 } 1531 data[config].call(this); 1532 } 1533 }); 1534 } 1535 }, { 1536 key: '_clearMenus', 1537 value: function _clearMenus(event) { 1538 if (event && event.which === RIGHT_MOUSE_BUTTON_WHICH) { 1539 return; 1540 } 1541 1542 var backdrop = $(Selector.BACKDROP)[0]; 1543 if (backdrop) { 1544 backdrop.parentNode.removeChild(backdrop); 1545 } 1546 1547 var toggles = $.makeArray($(Selector.DATA_TOGGLE)); 1548 1549 for (var i = 0; i < toggles.length; i++) { 1550 var _parent = Dropdown._getParentFromElement(toggles[i]); 1551 var relatedTarget = { relatedTarget: toggles[i] }; 1552 1553 if (!$(_parent).hasClass(ClassName.OPEN)) { 1554 continue; 1555 } 1556 1557 if (event && event.type === 'click' && /input|textarea/i.test(event.target.tagName) && $.contains(_parent, event.target)) { 1558 continue; 1559 } 1560 1561 var hideEvent = $.Event(Event.HIDE, relatedTarget); 1562 $(_parent).trigger(hideEvent); 1563 if (hideEvent.isDefaultPrevented()) { 1564 continue; 1565 } 1566 1567 toggles[i].setAttribute('aria-expanded', 'false'); 1568 1569 $(_parent).removeClass(ClassName.OPEN).trigger($.Event(Event.HIDDEN, relatedTarget)); 1570 } 1571 } 1572 }, { 1573 key: '_getParentFromElement', 1574 value: function _getParentFromElement(element) { 1575 var parent = undefined; 1576 var selector = Util.getSelectorFromElement(element); 1577 1578 if (selector) { 1579 parent = $(selector)[0]; 1580 } 1581 1582 return parent || element.parentNode; 1583 } 1584 }, { 1585 key: '_dataApiKeydownHandler', 1586 value: function _dataApiKeydownHandler(event) { 1587 if (!/(38|40|27|32)/.test(event.which) || /input|textarea/i.test(event.target.tagName)) { 1588 return; 1589 } 1590 1591 event.preventDefault(); 1592 event.stopPropagation(); 1593 1594 if (this.disabled || $(this).hasClass(ClassName.DISABLED)) { 1595 return; 1596 } 1597 1598 var parent = Dropdown._getParentFromElement(this); 1599 var isActive = $(parent).hasClass(ClassName.OPEN); 1600 1601 if (!isActive && event.which !== ESCAPE_KEYCODE || isActive && event.which === ESCAPE_KEYCODE) { 1602 1603 if (event.which === ESCAPE_KEYCODE) { 1604 var toggle = $(parent).find(Selector.DATA_TOGGLE)[0]; 1605 $(toggle).trigger('focus'); 1606 } 1607 1608 $(this).trigger('click'); 1609 return; 1610 } 1611 1612 var items = $.makeArray($(Selector.VISIBLE_ITEMS)); 1613 1614 items = items.filter(function (item) { 1615 return item.offsetWidth || item.offsetHeight; 1616 }); 1617 1618 if (!items.length) { 1619 return; 1620 } 1621 1622 var index = items.indexOf(event.target); 1623 1624 if (event.which === ARROW_UP_KEYCODE && index > 0) { 1625 // up 1626 index--; 1627 } 1628 1629 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { 1630 // down 1631 index++; 1632 } 1633 1634 if (index < 0) { 1635 index = 0; 1636 } 1637 1638 items[index].focus(); 1639 } 1640 }, {
1641 key: 'VERSION', 1642 get: function get() { 1643 return VERSION; 1644 } 1645 }]); 1646 1647 return Dropdown; 1648 })(); 1649 1650 $(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.ROLE_MENU, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.ROLE_LISTBOX, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, Dropdown.prototype.toggle).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) { 1651 e.stopPropagation(); 1652 }); 1653 1654 /** 1655 * ------------------------------------------------------------------------ 1656 * jQuery 1657 * ------------------------------------------------------------------------ 1658 */ 1659 1660 $.fn[NAME] = Dropdown._jQueryInterface; 1661 $.fn[NAME].Constructor = Dropdown; 1662 $.fn[NAME].noConflict = function () { 1663 $.fn[NAME] = JQUERY_NO_CONFLICT; 1664 return Dropdown._jQueryInterface; 1665 }; 1666 1667 return Dropdown; 1668})(jQuery); 1669 1670/** 1671 * -------------------------------------------------------------------------- 1672 * Bootstrap (v4.0.0-alpha.3): modal.js 1673 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 1674 * -------------------------------------------------------------------------- 1675 */ 1676 1677var Modal = (function ($) { 1678 1679 /** 1680 * ------------------------------------------------------------------------ 1681 * Constants 1682 * ------------------------------------------------------------------------ 1683 */ 1684 1685 var NAME = 'modal'; 1686 var VERSION = '4.0.0-alpha.3'; 1687 var DATA_KEY = 'bs.modal'; 1688 var EVENT_KEY = '.' + DATA_KEY; 1689 var DATA_API_KEY = '.data-api'; 1690 var JQUERY_NO_CONFLICT = $.fn[NAME]; 1691 var TRANSITION_DURATION = 300; 1692 var BACKDROP_TRANSITION_DURATION = 150; 1693 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 1694 1695 var Default = { 1696 backdrop: true, 1697 keyboard: true, 1698 focus: true, 1699 show: true 1700 }; 1701 1702 var DefaultType = { 1703 backdrop: '(boolean|string)', 1704 keyboard: 'boolean', 1705 focus: 'boolean', 1706 show: 'boolean' 1707 }; 1708 1709 var Event = { 1710 HIDE: 'hide' + EVENT_KEY, 1711 HIDDEN: 'hidden' + EVENT_KEY, 1712 SHOW: 'show' + EVENT_KEY, 1713 SHOWN: 'shown' + EVENT_KEY, 1714 FOCUSIN: 'focusin' + EVENT_KEY, 1715 RESIZE: 'resize' + EVENT_KEY, 1716 CLICK_DISMISS: 'click.dismiss' + EVENT_KEY, 1717 KEYDOWN_DISMISS: 'keydown.dismiss' + EVENT_KEY, 1718 MOUSEUP_DISMISS: 'mouseup.dismiss' + EVENT_KEY, 1719 MOUSEDOWN_DISMISS: 'mousedown.dismiss' + EVENT_KEY, 1720 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY 1721 }; 1722 1723 var ClassName = { 1724 SCROLLBAR_MEASURER: 'modal-scrollbar-measure', 1725 BACKDROP: 'modal-backdrop', 1726 OPEN: 'modal-open', 1727 FADE: 'fade', 1728 IN: 'in' 1729 }; 1730 1731 var Selector = { 1732 DIALOG: '.modal-dialog', 1733 DATA_TOGGLE: '[data-toggle="modal"]', 1734 DATA_DISMISS: '[data-dismiss="modal"]', 1735 FIXED_CONTENT: '.navbar-fixed-top, .navbar-fixed-bottom, .is-fixed' 1736 }; 1737 1738 /** 1739 * ------------------------------------------------------------------------ 1740 * Class Definition 1741 * ------------------------------------------------------------------------ 1742 */ 1743 1744 var Modal = (function () { 1745 function Modal(element, config) { 1746 _classCallCheck(this, Modal); 1747 1748 this._config = this._getConfig(config); 1749 this._element = element; 1750 this._dialog = $(element).find(Selector.DIALOG)[0]; 1751 this._backdrop = null; 1752 this._isShown = false; 1753 this._isBodyOverflowing = false; 1754 this._ignoreBackdropClick = false; 1755 this._originalBodyPadding = 0; 1756 this._scrollbarWidth = 0; 1757 } 1758 1759 /** 1760 * ------------------------------------------------------------------------ 1761 * Data Api implementation 1762 * ------------------------------------------------------------------------ 1763 */ 1764 1765 // getters 1766 1767 _createClass(Modal, [{ 1768 key: 'toggle', 1769 1770 // public 1771 1772 value: function toggle(relatedTarget) { 1773 return this._isShown ? this.hide() : this.show(relatedTarget); 1774 } 1775 }, { 1776 key: 'show', 1777 value: function show(relatedTarget) { 1778 var _this7 = this; 1779 1780 var showEvent = $.Event(Event.SHOW, { 1781 relatedTarget: relatedTarget 1782 }); 1783 1784 $(this._element).trigger(showEvent); 1785 1786 if (this._isShown || showEvent.isDefaultPrevented()) { 1787 return; 1788 } 1789 1790 this._isShown = true; 1791 1792 this._checkScrollbar(); 1793 this._setScrollbar(); 1794 1795 $(document.body).addClass(ClassName.OPEN); 1796 1797 this._setEscapeEvent(); 1798 this._setResizeEvent(); 1799 1800 $(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, $.proxy(this.hide, this)); 1801 1802 $(this._dialog).on(Event.MOUSEDOWN_DISMISS, function () { 1803 $(_this7._element).one(Event.MOUSEUP_DISMISS, function (event) { 1804 if ($(event.target).is(_this7._element)) { 1805 _this7._ignoreBackdropClick = true; 1806 } 1807 }); 1808 }); 1809 1810 this._showBackdrop($.proxy(this._showElement, this, relatedTarget)); 1811 } 1812 }, {
1813 key: 'hide', 1814 value: function hide(event) { 1815 if (event) { 1816 event.preventDefault(); 1817 } 1818 1819 var hideEvent = $.Event(Event.HIDE); 1820 1821 $(this._element).trigger(hideEvent); 1822 1823 if (!this._isShown || hideEvent.isDefaultPrevented()) { 1824 return; 1825 } 1826 1827 this._isShown = false; 1828 1829 this._setEscapeEvent(); 1830 this._setResizeEvent(); 1831 1832 $(document).off(Event.FOCUSIN); 1833 1834 $(this._element).removeClass(ClassName.IN); 1835 1836 $(this._element).off(Event.CLICK_DISMISS); 1837 $(this._dialog).off(Event.MOUSEDOWN_DISMISS); 1838 1839 if (Util.supportsTransitionEnd() && $(this._element).hasClass(ClassName.FADE)) { 1840 1841 $(this._element).one(Util.TRANSITION_END, $.proxy(this._hideModal, this)).emulateTransitionEnd(TRANSITION_DURATION); 1842 } else { 1843 this._hideModal(); 1844 } 1845 } 1846 }, { 1847 key: 'dispose', 1848 value: function dispose() { 1849 $.removeData(this._element, DATA_KEY); 1850 1851 $(window).off(EVENT_KEY); 1852 $(document).off(EVENT_KEY); 1853 $(this._element).off(EVENT_KEY); 1854 $(this._backdrop).off(EVENT_KEY); 1855 1856 this._config = null; 1857 this._element = null; 1858 this._dialog = null; 1859 this._backdrop = null; 1860 this._isShown = null; 1861 this._isBodyOverflowing = null; 1862 this._ignoreBackdropClick = null; 1863 this._originalBodyPadding = null; 1864 this._scrollbarWidth = null; 1865 } 1866 1867 // private 1868 1869 }, { 1870 key: '_getConfig', 1871 value: function _getConfig(config) { 1872 config = $.extend({}, Default, config); 1873 Util.typeCheckConfig(NAME, config, DefaultType); 1874 return config; 1875 } 1876 }, { 1877 key: '_showElement', 1878 value: function _showElement(relatedTarget) { 1879 var _this8 = this; 1880 1881 var transition = Util.supportsTransitionEnd() && $(this._element).hasClass(ClassName.FADE); 1882 1883 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 1884 // don't move modals dom position 1885 document.body.appendChild(this._element); 1886 } 1887 1888 this._element.style.display = 'block'; 1889 this._element.removeAttribute('aria-hidden'); 1890 this._element.scrollTop = 0; 1891 1892 if (transition) { 1893 Util.reflow(this._element); 1894 } 1895 1896 $(this._element).addClass(ClassName.IN); 1897 1898 if (this._config.focus) { 1899 this._enforceFocus(); 1900 } 1901 1902 var shownEvent = $.Event(Event.SHOWN, { 1903 relatedTarget: relatedTarget 1904 }); 1905 1906 var transitionComplete = function transitionComplete() { 1907 if (_this8._config.focus) { 1908 _this8._element.focus(); 1909 } 1910 $(_this8._element).trigger(shownEvent); 1911 }; 1912 1913 if (transition) { 1914 $(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(TRANSITION_DURATION); 1915 } else { 1916 transitionComplete(); 1917 } 1918 } 1919 }, { 1920 key: '_enforceFocus', 1921 value: function _enforceFocus() { 1922 var _this9 = this; 1923 1924 $(document).off(Event.FOCUSIN) // guard against infinite focus loop 1925 .on(Event.FOCUSIN, function (event) { 1926 if (document !== event.target && _this9._element !== event.target && !$(_this9._element).has(event.target).length) { 1927 _this9._element.focus(); 1928 } 1929 }); 1930 } 1931 }, { 1932 key: '_setEscapeEvent', 1933 value: function _setEscapeEvent() { 1934 var _this10 = this; 1935 1936 if (this._isShown && this._config.keyboard) { 1937 $(this._element).on(Event.KEYDOWN_DISMISS, function (event) { 1938 if (event.which === ESCAPE_KEYCODE) { 1939 _this10.hide(); 1940 } 1941 }); 1942 } else if (!this._isShown) { 1943 $(this._element).off(Event.KEYDOWN_DISMISS); 1944 } 1945 } 1946 }, { 1947 key: '_setResizeEvent', 1948 value: function _setResizeEvent() { 1949 if (this._isShown) { 1950 $(window).on(Event.RESIZE, $.proxy(this._handleUpdate, this)); 1951 } else { 1952 $(window).off(Event.RESIZE); 1953 } 1954 } 1955 }, {
1956 key: '_hideModal', 1957 value: function _hideModal() { 1958 var _this11 = this; 1959 1960 this._element.style.display = 'none'; 1961 this._element.setAttribute('aria-hidden', 'true'); 1962 this._showBackdrop(function () { 1963 $(document.body).removeClass(ClassName.OPEN); 1964 _this11._resetAdjustments(); 1965 _this11._resetScrollbar(); 1966 $(_this11._element).trigger(Event.HIDDEN); 1967 }); 1968 } 1969 }, { 1970 key: '_removeBackdrop', 1971 value: function _removeBackdrop() { 1972 if (this._backdrop) { 1973 $(this._backdrop).remove(); 1974 this._backdrop = null; 1975 } 1976 } 1977 }, { 1978 key: '_showBackdrop', 1979 value: function _showBackdrop(callback) { 1980 var _this12 = this; 1981 1982 var animate = $(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : ''; 1983 1984 if (this._isShown && this._config.backdrop) { 1985 var doAnimate = Util.supportsTransitionEnd() && animate; 1986 1987 this._backdrop = document.createElement('div'); 1988 this._backdrop.className = ClassName.BACKDROP; 1989 1990 if (animate) { 1991 $(this._backdrop).addClass(animate); 1992 } 1993 1994 $(this._backdrop).appendTo(document.body); 1995 1996 $(this._element).on(Event.CLICK_DISMISS, function (event) { 1997 if (_this12._ignoreBackdropClick) { 1998 _this12._ignoreBackdropClick = false; 1999 return; 2000 } 2001 if (event.target !== event.currentTarget) { 2002 return; 2003 } 2004 if (_this12._config.backdrop === 'static') { 2005 _this12._element.focus(); 2006 } else { 2007 _this12.hide(); 2008 } 2009 }); 2010 2011 if (doAnimate) { 2012 Util.reflow(this._backdrop); 2013 } 2014 2015 $(this._backdrop).addClass(ClassName.IN); 2016 2017 if (!callback) { 2018 return; 2019 } 2020 2021 if (!doAnimate) { 2022 callback(); 2023 return; 2024 } 2025 2026 $(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION); 2027 } else if (!this._isShown && this._backdrop) { 2028 $(this._backdrop).removeClass(ClassName.IN); 2029 2030 var callbackRemove = function callbackRemove() { 2031 _this12._removeBackdrop(); 2032 if (callback) { 2033 callback(); 2034 } 2035 }; 2036 2037 if (Util.supportsTransitionEnd() && $(this._element).hasClass(ClassName.FADE)) { 2038 $(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION); 2039 } else { 2040 callbackRemove(); 2041 } 2042 } else if (callback) { 2043 callback(); 2044 } 2045 } 2046 2047 // ---------------------------------------------------------------------- 2048 // the following methods are used to handle overflowing modals 2049 // todo (fat): these should probably be refactored out of modal.js 2050 // ---------------------------------------------------------------------- 2051 2052 }, { 2053 key: '_handleUpdate', 2054 value: function _handleUpdate() { 2055 this._adjustDialog(); 2056 } 2057 }, { 2058 key: '_adjustDialog', 2059 value: function _adjustDialog() { 2060 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 2061 2062 if (!this._isBodyOverflowing && isModalOverflowing) { 2063 this._element.style.paddingLeft = this._scrollbarWidth + 'px'; 2064 } 2065 2066 if (this._isBodyOverflowing && !isModalOverflowing) { 2067 this._element.style.paddingRight = this._scrollbarWidth + 'px'; 2068 } 2069 } 2070 }, { 2071 key: '_resetAdjustments', 2072 value: function _resetAdjustments() { 2073 this._element.style.paddingLeft = ''; 2074 this._element.style.paddingRight = ''; 2075 } 2076 }, { 2077 key: '_checkScrollbar', 2078 value: function _checkScrollbar() { 2079 this._isBodyOverflowing = document.body.clientWidth < window.innerWidth; 2080 this._scrollbarWidth = this._getScrollbarWidth(); 2081 } 2082 }, { 2083 key: '_setScrollbar', 2084 value: function _setScrollbar() { 2085 var bodyPadding = parseInt($(Selector.FIXED_CONTENT).css('padding-right') || 0, 10); 2086 2087 this._originalBodyPadding = document.body.style.paddingRight || ''; 2088 2089 if (this._isBodyOverflowing) { 2090 document.body.style.paddingRight = bodyPadding + this._scrollbarWidth + 'px'; 2091 } 2092 } 2093 }, {
2094 key: '_resetScrollbar', 2095 value: function _resetScrollbar() { 2096 document.body.style.paddingRight = this._originalBodyPadding; 2097 } 2098 }, { 2099 key: '_getScrollbarWidth', 2100 value: function _getScrollbarWidth() { 2101 // thx d.walsh 2102 var scrollDiv = document.createElement('div'); 2103 scrollDiv.className = ClassName.SCROLLBAR_MEASURER; 2104 document.body.appendChild(scrollDiv); 2105 var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth; 2106 document.body.removeChild(scrollDiv); 2107 return scrollbarWidth; 2108 } 2109 2110 // static 2111 2112 }], [{ 2113 key: '_jQueryInterface', 2114 value: function _jQueryInterface(config, relatedTarget) { 2115 return this.each(function () { 2116 var data = $(this).data(DATA_KEY); 2117 var _config = $.extend({}, Modal.Default, $(this).data(), typeof config === 'object' && config); 2118 2119 if (!data) { 2120 data = new Modal(this, _config); 2121 $(this).data(DATA_KEY, data); 2122 } 2123 2124 if (typeof config === 'string') { 2125 if (data[config] === undefined) { 2126 throw new Error('No method named "' + config + '"'); 2127 } 2128 data[config](relatedTarget); 2129 } else if (_config.show) { 2130 data.show(relatedTarget); 2131 } 2132 }); 2133 } 2134 }, { 2135 key: 'VERSION', 2136 get: function get() { 2137 return VERSION; 2138 } 2139 }, { 2140 key: 'Default', 2141 get: function get() { 2142 return Default; 2143 } 2144 }]); 2145 2146 return Modal; 2147 })(); 2148 2149 $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) { 2150 var _this13 = this; 2151 2152 var target = undefined; 2153 var selector = Util.getSelectorFromElement(this); 2154 2155 if (selector) { 2156 target = $(selector)[0]; 2157 } 2158 2159 var config = $(target).data(DATA_KEY) ? 'toggle' : $.extend({}, $(target).data(), $(this).data()); 2160 2161 if (this.tagName === 'A') { 2162 event.preventDefault(); 2163 } 2164 2165 var $target = $(target).one(Event.SHOW, function (showEvent) { 2166 if (showEvent.isDefaultPrevented()) { 2167 // only register focus restorer if modal will actually get shown 2168 return; 2169 } 2170 2171 $target.one(Event.HIDDEN, function () { 2172 if ($(_this13).is(':visible')) { 2173 _this13.focus(); 2174 } 2175 }); 2176 }); 2177 2178 Modal._jQueryInterface.call($(target), config, this); 2179 }); 2180 2181 /** 2182 * ------------------------------------------------------------------------ 2183 * jQuery 2184 * ------------------------------------------------------------------------ 2185 */ 2186 2187 $.fn[NAME] = Modal._jQueryInterface; 2188 $.fn[NAME].Constructor = Modal; 2189 $.fn[NAME].noConflict = function () { 2190 $.fn[NAME] = JQUERY_NO_CONFLICT; 2191 return Modal._jQueryInterface; 2192 }; 2193 2194 return Modal; 2195})(jQuery); 2196 2197/** 2198 * -------------------------------------------------------------------------- 2199 * Bootstrap (v4.0.0-alpha.3): scrollspy.js 2200 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 2201 * -------------------------------------------------------------------------- 2202 */ 2203 2204var ScrollSpy = (function ($) { 2205 2206 /** 2207 * ------------------------------------------------------------------------ 2208 * Constants 2209 * ------------------------------------------------------------------------ 2210 */ 2211 2212 var NAME = 'scrollspy'; 2213 var VERSION = '4.0.0-alpha.3'; 2214 var DATA_KEY = 'bs.scrollspy'; 2215 var EVENT_KEY = '.' + DATA_KEY; 2216 var DATA_API_KEY = '.data-api'; 2217 var JQUERY_NO_CONFLICT = $.fn[NAME]; 2218 2219 var Default = { 2220 offset: 10, 2221 method: 'auto', 2222 target: '' 2223 }; 2224 2225 var DefaultType = { 2226 offset: 'number', 2227 method: 'string', 2228 target: '(string|element)' 2229 }; 2230 2231 var Event = { 2232 ACTIVATE: 'activate' + EVENT_KEY, 2233 SCROLL: 'scroll' + EVENT_KEY, 2234 LOAD_DATA_API: 'load' + EVENT_KEY + DATA_API_KEY 2235 }; 2236 2237 var ClassName = { 2238 DROPDOWN_ITEM: 'dropdown-item', 2239 DROPDOWN_MENU: 'dropdown-menu', 2240 NAV_LINK: 'nav-link', 2241 NAV: 'nav', 2242 ACTIVE: 'active' 2243 }; 2244 2245 var Selector = { 2246 DATA_SPY: '[data-spy="scroll"]', 2247 ACTIVE: '.active', 2248 LIST_ITEM: '.list-item', 2249 LI: 'li', 2250 LI_DROPDOWN: 'li.dropdown', 2251 NAV_LINKS: '.nav-link', 2252 DROPDOWN: '.dropdown',
2253 DROPDOWN_ITEMS: '.dropdown-item', 2254 DROPDOWN_TOGGLE: '.dropdown-toggle' 2255 }; 2256 2257 var OffsetMethod = { 2258 OFFSET: 'offset', 2259 POSITION: 'position' 2260 }; 2261 2262 /** 2263 * ------------------------------------------------------------------------ 2264 * Class Definition 2265 * ------------------------------------------------------------------------ 2266 */ 2267 2268 var ScrollSpy = (function () { 2269 function ScrollSpy(element, config) { 2270 _classCallCheck(this, ScrollSpy); 2271 2272 this._element = element; 2273 this._scrollElement = element.tagName === 'BODY' ? window : element; 2274 this._config = this._getConfig(config); 2275 this._selector = this._config.target + ' ' + Selector.NAV_LINKS + ',' + (this._config.target + ' ' + Selector.DROPDOWN_ITEMS); 2276 this._offsets = []; 2277 this._targets = []; 2278 this._activeTarget = null; 2279 this._scrollHeight = 0; 2280 2281 $(this._scrollElement).on(Event.SCROLL, $.proxy(this._process, this)); 2282 2283 this.refresh(); 2284 this._process(); 2285 } 2286 2287 /** 2288 * ------------------------------------------------------------------------ 2289 * Data Api implementation 2290 * ------------------------------------------------------------------------ 2291 */ 2292 2293 // getters 2294 2295 _createClass(ScrollSpy, [{ 2296 key: 'refresh', 2297 2298 // public 2299 2300 value: function refresh() { 2301 var _this14 = this; 2302 2303 var autoMethod = this._scrollElement !== this._scrollElement.window ? OffsetMethod.POSITION : OffsetMethod.OFFSET; 2304 2305 var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; 2306 2307 var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0; 2308 2309 this._offsets = []; 2310 this._targets = []; 2311 2312 this._scrollHeight = this._getScrollHeight(); 2313 2314 var targets = $.makeArray($(this._selector)); 2315 2316 targets.map(function (element) { 2317 var target = undefined; 2318 var targetSelector = Util.getSelectorFromElement(element); 2319 2320 if (targetSelector) { 2321 target = $(targetSelector)[0]; 2322 } 2323 2324 if (target && (target.offsetWidth || target.offsetHeight)) { 2325 // todo (fat): remove sketch reliance on jQuery position/offset 2326 return [$(target)[offsetMethod]().top + offsetBase, targetSelector]; 2327 } 2328 return null; 2329 }).filter(function (item) { 2330 return item; 2331 }).sort(function (a, b) { 2332 return a[0] - b[0]; 2333 }
2333).forEach(function (item) { 2334 _this14._offsets.push(item[0]); 2335 _this14._targets.push(item[1]); 2336 }); 2337 } 2338 }, { 2339 key: 'dispose', 2340 value: function dispose() { 2341 $.removeData(this._element, DATA_KEY); 2342 $(this._scrollElement).off(EVENT_KEY); 2343 2344 this._element = null; 2345 this._scrollElement = null; 2346 this._config = null; 2347 this._selector = null; 2348 this._offsets = null; 2349 this._targets = null; 2350 this._activeTarget = null; 2351 this._scrollHeight = null; 2352 } 2353 2354 // private 2355 2356 }, { 2357 key: '_getConfig', 2358 value: function _getConfig(config) { 2359 config = $.extend({}, Default, config); 2360 2361 if (typeof config.target !== 'string') { 2362 var id = $(config.target).attr('id'); 2363 if (!id) { 2364 id = Util.getUID(NAME); 2365 $(config.target).attr('id', id); 2366 } 2367 config.target = '#' + id; 2368 } 2369 2370 Util.typeCheckConfig(NAME, config, DefaultType); 2371 2372 return config; 2373 } 2374 }, { 2375 key: '_getScrollTop', 2376 value: function _getScrollTop() { 2377 return this._scrollElement === window ? this._scrollElement.scrollY : this._scrollElement.scrollTop; 2378 } 2379 }, { 2380 key: '_getScrollHeight', 2381 value: function _getScrollHeight() { 2382 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); 2383 } 2384 }, { 2385 key: '_process', 2386 value: function _process() { 2387 var scrollTop = this._getScrollTop() + this._config.offset; 2388 var scrollHeight = this._getScrollHeight(); 2389 var maxScroll = this._config.offset + scrollHeight - this._scrollElement.offsetHeight; 2390 2391 if (this._scrollHeight !== scrollHeight) { 2392 this.refresh(); 2393 } 2394 2395 if (scrollTop >= maxScroll) { 2396 var target = this._targets[this._targets.length - 1]; 2397 2398 if (this._activeTarget !== target) { 2399 this._activate(target); 2400 } 2401 } 2402 2403 if (this._activeTarget && scrollTop < this._offsets[0]) { 2404 this._activeTarget = null; 2405 this._clear(); 2406 return; 2407 } 2408 2409 for (var i = this._offsets.length; i--;) { 2410 var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (this._offsets[i + 1] === undefined || scrollTop < this._offsets[i + 1]); 2411 2412 if (isActiveTarget) { 2413 this._activate(this._targets[i]); 2414 } 2415 } 2416 } 2417 }, { 2418 key: '_activate', 2419 value: function _activate(target) { 2420 this._activeTarget = target; 2421 2422 this._clear(); 2423 2424 var queries = this._selector.split(','); 2425 queries = queries.map(function (selector) { 2426 return selector + '[data-target="' + target + '"],' + (selector + '[href="' + target + '"]'); 2427 }); 2428 2429 var $link = $(queries.join(',')); 2430 2431 if ($link.hasClass(ClassName.DROPDOWN_ITEM)) { 2432 $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE); 2433 $link.addClass(ClassName.ACTIVE); 2434 } else { 2435 // todo (fat) this is kinda sus... 2436 // recursively add actives to tested nav-links 2437 $link.parents(Selector.LI).find(Selector.NAV_LINKS).addClass(ClassName.ACTIVE); 2438 } 2439 2440 $(this._scrollElement).trigger(Event.ACTIVATE, { 2441 relatedTarget: target 2442 }); 2443 } 2444 }, { 2445 key: '_clear', 2446 value: function _clear() { 2447 $(this._selector).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE); 2448 } 2449 2450 // static 2451 2452 }], [{ 2453 key: '_jQueryInterface', 2454 value: function _jQueryInterface(config) { 2455 return this.each(function () { 2456 var data = $(this).data(DATA_KEY); 2457 var _config = typeof config === 'object' && config || null; 2458 2459 if (!data) { 2460 data = new ScrollSpy(this, _config); 2461 $(this).data(DATA_KEY, data); 2462 } 2463 2464 if (typeof config === 'string') { 2465 if (data[config] === undefined) {
2466 throw new Error('No method named "' + config + '"'); 2467 } 2468 data[config](); 2469 } 2470 }); 2471 } 2472 }, { 2473 key: 'VERSION', 2474 get: function get() { 2475 return VERSION; 2476 } 2477 }, { 2478 key: 'Default', 2479 get: function get() { 2480 return Default; 2481 } 2482 }]); 2483 2484 return ScrollSpy; 2485 })(); 2486 2487 $(window).on(Event.LOAD_DATA_API, function () { 2488 var scrollSpys = $.makeArray($(Selector.DATA_SPY)); 2489 2490 for (var i = scrollSpys.length; i--;) { 2491 var $spy = $(scrollSpys[i]); 2492 ScrollSpy._jQueryInterface.call($spy, $spy.data()); 2493 } 2494 }); 2495 2496 /** 2497 * ------------------------------------------------------------------------ 2498 * jQuery 2499 * ------------------------------------------------------------------------ 2500 */ 2501 2502 $.fn[NAME] = ScrollSpy._jQueryInterface; 2503 $.fn[NAME].Constructor = ScrollSpy; 2504 $.fn[NAME].noConflict = function () { 2505 $.fn[NAME] = JQUERY_NO_CONFLICT; 2506 return ScrollSpy._jQueryInterface; 2507 }; 2508 2509 return ScrollSpy; 2510})(jQuery); 2511 2512/** 2513 * -------------------------------------------------------------------------- 2514 * Bootstrap (v4.0.0-alpha.3): tab.js 2515 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 2516 * -------------------------------------------------------------------------- 2517 */ 2518 2519var Tab = (function ($) { 2520 2521 /** 2522 * ------------------------------------------------------------------------ 2523 * Constants 2524 * ------------------------------------------------------------------------ 2525 */ 2526 2527 var NAME = 'tab'; 2528 var VERSION = '4.0.0-alpha.3'; 2529 var DATA_KEY = 'bs.tab'; 2530 var EVENT_KEY = '.' + DATA_KEY; 2531 var DATA_API_KEY = '.data-api'; 2532 var JQUERY_NO_CONFLICT = $.fn[NAME]; 2533 var TRANSITION_DURATION = 150; 2534 2535 var Event = { 2536 HIDE: 'hide' + EVENT_KEY, 2537 HIDDEN: 'hidden' + EVENT_KEY, 2538 SHOW: 'show' + EVENT_KEY, 2539 SHOWN: 'shown' + EVENT_KEY, 2540 CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY 2541 }; 2542 2543 var ClassName = { 2544 DROPDOWN_MENU: 'dropdown-menu', 2545 ACTIVE: 'active', 2546 FADE: 'fade', 2547 IN: 'in' 2548 }; 2549 2550 var Selector = { 2551 A: 'a', 2552 LI: 'li', 2553 DROPDOWN: '.dropdown', 2554 UL: 'ul:not(.dropdown-menu)', 2555 FADE_CHILD: '> .nav-item .fade, > .fade', 2556 ACTIVE: '.active', 2557 ACTIVE_CHILD: '> .nav-item > .active, > .active', 2558 DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"]', 2559 DROPDOWN_TOGGLE: '.dropdown-toggle', 2560 DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active' 2561 }; 2562 2563 /** 2564 * ------------------------------------------------------------------------ 2565 * Class Definition 2566 * ------------------------------------------------------------------------ 2567 */ 2568 2569 var Tab = (function () { 2570 function Tab(element) { 2571 _classCallCheck(this, Tab); 2572 2573 this._element = element; 2574 } 2575 2576 /** 2577 * ------------------------------------------------------------------------ 2578 * Data Api implementation 2579 * ------------------------------------------------------------------------ 2580 */ 2581 2582 // getters 2583 2584 _createClass(Tab, [{ 2585 key: 'show', 2586 2587 // public 2588 2589 value: function show() { 2590 var _this15 = this; 2591 2592 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $(this._element).hasClass(ClassName.ACTIVE)) { 2593 return; 2594 } 2595 2596 var target = undefined; 2597 var previous = undefined; 2598 var ulElement = $(this._element).closest(Selector.UL)[0]; 2599 var selector = Util.getSelectorFromElement(this._element); 2600 2601 if (ulElement) { 2602 previous = $.makeArray($(ulElement).find(Selector.ACTIVE)); 2603 previous = previous[previous.length - 1]; 2604 } 2605 2606 var hideEvent = $.Event(Event.HIDE, { 2607 relatedTarget: this._element 2608 }); 2609 2610 var showEvent = $.Event(Event.SHOW, { 2611 relatedTarget: previous 2612 }); 2613 2614 if (previous) { 2615 $(previous).trigger(hideEvent); 2616 } 2617 2618 $(this._element).trigger(showEvent); 2619 2620 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { 2621 return; 2622 } 2623 2624 if (selector) { 2625 target = $(selector)[0]; 2626 } 2627 2628 this._activate(this._element, ulElement); 2629 2630 var complete = function complete() { 2631 var hiddenEvent = $.Event(Event.HIDDEN, { 2632 relatedTarget: _this15._element 2633 }); 2634 2635 var shownEvent = $.Event(Event.SHOWN, { 2636 relatedTarget: previous 2637 }); 2638 2639 $(previous).trigger(hiddenEvent); 2640 $(_this15._element).trigger(shownEvent); 2641 }; 2642 2643 if (target) { 2644 this._activate(target, target.parentNode, complete); 2645 } else { 2646 complete(); 2647 } 2648 } 2649 }, {
2650 key: 'dispose', 2651 value: function dispose() { 2652 $.removeClass(this._element, DATA_KEY); 2653 this._element = null; 2654 } 2655 2656 // private 2657 2658 }, { 2659 key: '_activate', 2660 value: function _activate(element, container, callback) { 2661 var active = $(container).find(Selector.ACTIVE_CHILD)[0]; 2662 var isTransitioning = callback && Util.supportsTransitionEnd() && (active && $(active).hasClass(ClassName.FADE) || Boolean($(container).find(Selector.FADE_CHILD)[0])); 2663 2664 var complete = $.proxy(this._transitionComplete, this, element, active, isTransitioning, callback); 2665 2666 if (active && isTransitioning) { 2667 $(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION); 2668 } else { 2669 complete(); 2670 } 2671 2672 if (active) { 2673 $(active).removeClass(ClassName.IN); 2674 } 2675 } 2676 }, { 2677 key: '_transitionComplete', 2678 value: function _transitionComplete(element, active, isTransitioning, callback) { 2679 if (active) { 2680 $(active).removeClass(ClassName.ACTIVE); 2681
2682 var dropdownChild = $(active).find(Selector.DROPDOWN_ACTIVE_CHILD)[0]; 2683 2684 if (dropdownChild) { 2685 $(dropdownChild).removeClass(ClassName.ACTIVE); 2686 } 2687 2688 active.setAttribute('aria-expanded', false); 2689 } 2690 2691 $(element).addClass(ClassName.ACTIVE); 2692 element.setAttribute('aria-expanded', true); 2693 2694 if (isTransitioning) { 2695 Util.reflow(element); 2696 $(element).addClass(ClassName.IN); 2697 } else { 2698 $(element).removeClass(ClassName.FADE); 2699 } 2700 2701 if (element.parentNode && $(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) { 2702 2703 var dropdownElement = $(element).closest(Selector.DROPDOWN)[0]; 2704 if (dropdownElement) { 2705 $(dropdownElement).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE); 2706 } 2707 2708 element.setAttribute('aria-expanded', true); 2709 } 2710 2711 if (callback) { 2712 callback(); 2713 } 2714 } 2715 2716 // static 2717 2718 }], [{ 2719 key: '_jQueryInterface', 2720 value: function _jQueryInterface(config) { 2721 return this.each(function () { 2722 var $this = $(this); 2723 var data = $this.data(DATA_KEY); 2724 2725 if (!data) { 2726 data = data = new Tab(this); 2727 $this.data(DATA_KEY, data); 2728 } 2729 2730 if (typeof config === 'string') { 2731 if (data[config] === undefined) { 2732 throw new Error('No method named "' + config + '"'); 2733 } 2734 data[config](); 2735 } 2736 }); 2737 } 2738 }, { 2739 key: 'VERSION', 2740 get: function get() { 2741 return VERSION; 2742 } 2743 }]); 2744 2745 return Tab; 2746 })(); 2747 2748 $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) { 2749 event.preventDefault(); 2750 Tab._jQueryInterface.call($(this), 'show'); 2751 }); 2752 2753 /** 2754 * ------------------------------------------------------------------------ 2755 * jQuery 2756 * ------------------------------------------------------------------------ 2757 */ 2758 2759 $.fn[NAME] = Tab._jQueryInterface; 2760 $.fn[NAME].Constructor = Tab; 2761 $.fn[NAME].noConflict = function () { 2762 $.fn[NAME] = JQUERY_NO_CONFLICT; 2763 return Tab._jQueryInterface; 2764 }; 2765 2766 return Tab; 2767})(jQuery); 2768 2769/* global Tether */ 2770 2771/** 2772 * -------------------------------------------------------------------------- 2773 * Bootstrap (v4.0.0-alpha.3): tooltip.js 2774 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 2775 * -------------------------------------------------------------------------- 2776 */ 2777 2778var Tooltip = (function ($) { 2779 2780 /** 2781 * Check for Tether dependency 2782 * Tether - http://github.hubspot.com/tether/ 2783 */ 2784 if (window.Tether === undefined) { 2785 throw new Error('Bootstrap tooltips require Tether (http://github.hubspot.com/tether/)'); 2786 } 2787 2788 /** 2789 * ------------------------------------------------------------------------ 2790 * Constants 2791 * ------------------------------------------------------------------------ 2792 */ 2793 2794 var NAME = 'tooltip'; 2795 var VERSION = '4.0.0-alpha.3'; 2796 var DATA_KEY = 'bs.tooltip'; 2797 var EVENT_KEY = '.' + DATA_KEY; 2798 var JQUERY_NO_CONFLICT = $.fn[NAME]; 2799 var TRANSITION_DURATION = 150; 2800 var CLASS_PREFIX = 'bs-tether'; 2801 2802 var Default = { 2803 animation: true, 2804 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div></div>', 2805 trigger: 'hover focus', 2806 title: '', 2807 delay: 0, 2808 html: false, 2809 selector: false, 2810 placement: 'top', 2811 offset: '0 0', 2812 constraints: [] 2813 }; 2814 2815 var DefaultType = { 2816 animation: 'boolean', 2817 template: 'string', 2818 title: '(string|element|function)', 2819 trigger: 'string', 2820 delay: '(number|object)', 2821 html: 'boolean', 2822 selector: '(string|boolean)', 2823 placement: '(string|function)', 2824 offset: 'string', 2825 constraints: 'array' 2826 }; 2827 2828 var AttachmentMap = { 2829 TOP: 'bottom center', 2830 RIGHT: 'middle left', 2831 BOTTOM: 'top center', 2832 LEFT: 'middle right' 2833 }; 2834 2835 var HoverState = { 2836 IN: 'in', 2837 OUT: 'out' 2838 }; 2839 2840 var Event = { 2841 HIDE: 'hide' + EVENT_KEY, 2842 HIDDEN: 'hidden' + EVENT_KEY, 2843 SHOW: 'show' + EVENT_KEY, 2844 SHOWN: 'shown' + EVENT_KEY,
2845 INSERTED: 'inserted' + EVENT_KEY, 2846 CLICK: 'click' + EVENT_KEY, 2847 FOCUSIN: 'focusin' + EVENT_KEY, 2848 FOCUSOUT: 'focusout' + EVENT_KEY, 2849 MOUSEENTER: 'mouseenter' + EVENT_KEY, 2850 MOUSELEAVE: 'mouseleave' + EVENT_KEY 2851 }; 2852 2853 var ClassName = { 2854 FADE: 'fade', 2855 IN: 'in' 2856 }; 2857 2858 var Selector = { 2859 TOOLTIP: '.tooltip', 2860 TOOLTIP_INNER: '.tooltip-inner' 2861 }; 2862 2863 var TetherClass = { 2864 element: false, 2865 enabled: false 2866 }; 2867 2868 var Trigger = { 2869 HOVER: 'hover', 2870 FOCUS: 'focus', 2871 CLICK: 'click', 2872 MANUAL: 'manual' 2873 }; 2874 2875 /** 2876 * ------------------------------------------------------------------------ 2877 * Class Definition 2878 * ------------------------------------------------------------------------ 2879 */ 2880 2881 var Tooltip = (function () { 2882 function Tooltip(element, config) { 2883 _classCallCheck(this, Tooltip); 2884 2885 // private 2886 this._isEnabled = true; 2887 this._timeout = 0; 2888 this._hoverState = ''; 2889 this._activeTrigger = {}; 2890 this._tether = null; 2891 2892 // protected 2893 this.element = element; 2894 this.config = this._getConfig(config); 2895 this.tip = null; 2896 2897 this._setListeners(); 2898 } 2899 2900 /** 2901 * ------------------------------------------------------------------------ 2902 * jQuery 2903 * ------------------------------------------------------------------------ 2904 */ 2905 2906 // getters 2907 2908 _createClass(Tooltip, [{ 2909 key: 'enable', 2910 2911 // public 2912 2913 value: function enable() { 2914 this._isEnabled = true; 2915 } 2916 }, { 2917 key: 'disable', 2918 value: function disable() { 2919 this._isEnabled = false; 2920 } 2921 }, { 2922 key: 'toggleEnabled', 2923 value: function toggleEnabled() { 2924 this._isEnabled = !this._isEnabled; 2925 } 2926 }, { 2927 key: 'toggle', 2928 value: function toggle(event) { 2929 if (event) { 2930 var dataKey = this.constructor.DATA_KEY; 2931 var context = $(event.currentTarget).data(dataKey); 2932 2933 if (!context) { 2934 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 2935 $(event.currentTarget).data(dataKey, context); 2936 } 2937 2938 context._activeTrigger.click = !context._activeTrigger.click; 2939 2940 if (context._isWithActiveTrigger()) { 2941 context._enter(null, context); 2942 } else { 2943 context._leave(null, context); 2944 } 2945 } else { 2946 2947 if ($(this.getTipElement()).hasClass(ClassName.IN)) { 2948 this._leave(null, this); 2949 return; 2950 } 2951 2952 this._enter(null, this); 2953 } 2954 } 2955 }, { 2956 key: 'dispose', 2957 value: function dispose() { 2958 clearTimeout(this._timeout); 2959 2960 this.cleanupTether(); 2961 2962 $.removeData(this.element, this.constructor.DATA_KEY); 2963 2964 $(this.element).off(this.constructor.EVENT_KEY); 2965 2966 if (this.tip) { 2967 $(this.tip).remove(); 2968 } 2969 2970 this._isEnabled = null; 2971 this._timeout = null; 2972 this._hoverState = null; 2973 this._activeTrigger = null; 2974 this._tether = null; 2975 2976 this.element = null; 2977 this.config = null; 2978 this.tip = null; 2979 } 2980 }, { 2981 key: 'show', 2982 value: function show() { 2983 var _this16 = this; 2984 2985 var showEvent = $.Event(this.constructor.Event.SHOW); 2986 2987 if (this.isWithContent() && this._isEnabled) { 2988 $(this.element).trigger(showEvent); 2989 2990 var isInTheDom = $.contains(this.element.ownerDocument.documentElement, this.element); 2991 2992 if (showEvent.isDefaultPrevented() || !isInTheDom) { 2993 return; 2994 } 2995 2996 var tip = this.getTipElement(); 2997 var tipId = Util.getUID(this.constructor.NAME); 2998
2999 tip.setAttribute('id', tipId); 3000 this.element.setAttribute('aria-describedby', tipId); 3001 3002 this.setContent(); 3003 3004 if (this.config.animation) { 3005 $(tip).addClass(ClassName.FADE); 3006 } 3007 3008 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; 3009 3010 var attachment = this._getAttachment(placement); 3011 3012 $(tip).data(this.constructor.DATA_KEY, this).appendTo(document.body); 3013 3014 $(this.element).trigger(this.constructor.Event.INSERTED); 3015 3016 this._tether = new Tether({ 3017 attachment: attachment, 3018 element: tip, 3019 target: this.element, 3020 classes: TetherClass, 3021 classPrefix: CLASS_PREFIX, 3022 offset: this.config.offset, 3023 constraints: this.config.constraints, 3024 addTargetClasses: false 3025 }); 3026 3027 Util.reflow(tip); 3028 this._tether.position(); 3029 3030 $(tip).addClass(ClassName.IN); 3031 3032 var complete = function complete() { 3033 var prevHoverState = _this16._hoverState; 3034 _this16._hoverState = null; 3035 3036 $(_this16.element).trigger(_this16.constructor.Event.SHOWN); 3037 3038 if (prevHoverState === HoverState.OUT) { 3039 _this16._leave(null, _this16); 3040 } 3041 }; 3042 3043 if (Util.supportsTransitionEnd() && $(this.tip).hasClass(ClassName.FADE)) { 3044 $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION); 3045 return; 3046 } 3047 3048 complete(); 3049 } 3050 } 3051 }, { 3052 key: 'hide', 3053 value: function hide(callback) { 3054 var _this17 = this; 3055 3056 var tip = this.getTipElement(); 3057 var hideEvent = $.Event(this.constructor.Event.HIDE); 3058 var complete = function complete() { 3059 if (_this17._hoverState !== HoverState.IN && tip.parentNode) { 3060 tip.parentNode.removeChild(tip); 3061 } 3062 3063 _this17.element.removeAttribute('aria-describedby'); 3064 $(_this17.element).trigger(_this17.constructor.Event.HIDDEN); 3065 _this17.cleanupTether(); 3066 3067 if (callback) { 3068 callback(); 3069 } 3070 }; 3071 3072 $(this.element).trigger(hideEvent); 3073 3074 if (hideEvent.isDefaultPrevented()) { 3075 return; 3076 } 3077 3078 $(tip).removeClass(ClassName.IN); 3079 3080 if (Util.supportsTransitionEnd() && $(this.tip).hasClass(ClassName.FADE)) { 3081 3082 $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION); 3083 } else { 3084 complete(); 3085 } 3086 3087 this._hoverState = ''; 3088 } 3089 3090 // protected 3091 3092 }, { 3093 key: 'isWithContent', 3094 value: function isWithContent() { 3095 return Boolean(this.getTitle()); 3096 } 3097 }, { 3098 key: 'getTipElement', 3099 value: function getTipElement() { 3100 return this.tip = this.tip || $(this.config.template)[0]; 3101 } 3102 }, { 3103 key: 'setContent', 3104 value: function setContent() { 3105 var $tip = $(this.getTipElement()); 3106 3107 this.setElementContent($tip.find(Selector.TOOLTIP_INNER), this.getTitle()); 3108 3109 $tip.removeClass(ClassName.FADE).removeClass(ClassName.IN); 3110 3111 this.cleanupTether(); 3112 } 3113 }, { 3114 key: 'setElementContent', 3115 value: function setElementContent($element, content) { 3116 var html = this.config.html; 3117 if (typeof content === 'object' && (content.nodeType || content.jquery)) { 3118 // content is a DOM node or a jQuery 3119 if (html) { 3120 if (!$(content).parent().is($element)) { 3121 $element.empty().append(content); 3122 } 3123 } else { 3124 $element.text($(content).text()); 3125 } 3126 } else { 3127 $element[html ? 'html' : 'text'](content); 3128 } 3129 } 3130 }, { 3131 key: 'getTitle', 3132 value: function getTitle() { 3133 var title = this.element.getAttribute('data-original-title'); 3134 3135 if (!title) { 3136 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; 3137 } 3138 3139 return title; 3140 } 3141 }, {
3142 key: 'cleanupTether', 3143 value: function cleanupTether() { 3144 if (this._tether) { 3145 this._tether.destroy(); 3146 } 3147 } 3148 3149 // private 3150 3151 }, { 3152 key: '_getAttachment', 3153 value: function _getAttachment(placement) { 3154 return AttachmentMap[placement.toUpperCase()]; 3155 } 3156 }, { 3157 key: '_setListeners', 3158 value: function _setListeners() { 3159 var _this18 = this; 3160 3161 var triggers = this.config.trigger.split(' '); 3162 3163 triggers.forEach(function (trigger) { 3164 if (trigger === 'click') { 3165 $(_this18.element).on(_this18.constructor.Event.CLICK, _this18.config.selector, $.proxy(_this18.toggle, _this18)); 3166 } else if (trigger !== Trigger.MANUAL) { 3167 var eventIn = trigger === Trigger.HOVER ? _this18.constructor.Event.MOUSEENTER : _this18.constructor.Event.FOCUSIN; 3168 var eventOut = trigger === Trigger.HOVER ? _this18.constructor.Event.MOUSELEAVE : _this18.constructor.Event.FOCUSOUT; 3169 3170 $(_this18.element).on(eventIn, _this18.config.selector, $.proxy(_this18._enter, _this18)).on(eventOut, _this18.config.selector, $.proxy(_this18._leave, _this18)); 3171 } 3172 }); 3173 3174 if (this.config.selector) { 3175 this.config = $.extend({}, this.config, { 3176 trigger: 'manual', 3177 selector: '' 3178 }); 3179 } else { 3180 this._fixTitle(); 3181 } 3182 } 3183 }, { 3184 key: '_fixTitle', 3185 value: function _fixTitle() { 3186 var titleType = typeof this.element.getAttribute('data-original-title'); 3187 if (this.element.getAttribute('title') || titleType !== 'string') { 3188 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); 3189 this.element.setAttribute('title', ''); 3190 } 3191 } 3192 }, { 3193 key: '_enter', 3194 value: function _enter(event, context) { 3195 var dataKey = this.constructor.DATA_KEY; 3196 3197 context = context || $(event.currentTarget).data(dataKey); 3198 3199 if (!context) { 3200 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3201 $(event.currentTarget).data(dataKey, context); 3202 } 3203 3204 if (event) { 3205 context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true; 3206 } 3207 3208 if ($(context.getTipElement()).hasClass(ClassName.IN) || context._hoverState === HoverState.IN) { 3209 context._hoverState = HoverState.IN; 3210 return; 3211 } 3212 3213 clearTimeout(context._timeout); 3214 3215 context._hoverState = HoverState.IN; 3216 3217 if (!context.config.delay || !context.config.delay.show) { 3218 context.show(); 3219 return; 3220 } 3221 3222 context._timeout = setTimeout(function () { 3223 if (context._hoverState === HoverState.IN) { 3224 context.show(); 3225 } 3226 }, context.config.delay.show); 3227 } 3228 }, { 3229 key: '_leave', 3230 value: function _leave(event, context) { 3231 var dataKey = this.constructor.DATA_KEY; 3232 3233 context = context || $(event.currentTarget).data(dataKey); 3234 3235 if (!context) { 3236 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3237 $(event.currentTarget).data(dataKey, context); 3238 } 3239 3240 if (event) { 3241 context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false; 3242 } 3243 3244 if (context._isWithActiveTrigger()) { 3245 return; 3246 } 3247 3248 clearTimeout(context._timeout); 3249 3250 context._hoverState = HoverState.OUT; 3251 3252 if (!context.config.delay || !context.config.delay.hide) { 3253 context.hide(); 3254 return; 3255 } 3256 3257 context._timeout = setTimeout(function () { 3258 if (context._hoverState === HoverState.OUT) { 3259 context.hide(); 3260 } 3261 }, context.config.delay.hide); 3262 } 3263 }, { 3264 key: '_isWithActiveTrigger', 3265 value: function _isWithActiveTrigger() { 3266 for (var trigger in this._activeTrigger) { 3267 if (this._activeTrigger[trigger]) { 3268 return true; 3269 } 3270 } 3271 3272 return false;
3273 } 3274 }, { 3275 key: '_getConfig', 3276 value: function _getConfig(config) { 3277 config = $.extend({}, this.constructor.Default, $(this.element).data(), config); 3278 3279 if (config.delay && typeof config.delay === 'number') { 3280 config.delay = { 3281 show: config.delay, 3282 hide: config.delay 3283 }; 3284 } 3285 3286 Util.typeCheckConfig(NAME, config, this.constructor.DefaultType); 3287 3288 return config; 3289 } 3290 }, { 3291 key: '_getDelegateConfig', 3292 value: function _getDelegateConfig() { 3293 var config = {}; 3294 3295 if (this.config) { 3296 for (var key in this.config) { 3297 if (this.constructor.Default[key] !== this.config[key]) { 3298 config[key] = this.config[key]; 3299 } 3300 } 3301 } 3302 3303 return config; 3304 } 3305 3306 // static 3307 3308 }], [{ 3309 key: '_jQueryInterface', 3310 value: function _jQueryInterface(config) { 3311 return this.each(function () { 3312 var data = $(this).data(DATA_KEY); 3313 var _config = typeof config === 'object' ? config : null; 3314 3315 if (!data && /destroy|hide/.test(config)) { 3316 return; 3317 } 3318 3319 if (!data) { 3320 data = new Tooltip(this, _config); 3321 $(this).data(DATA_KEY, data); 3322 } 3323 3324 if (typeof config === 'string') { 3325 if (data[config] === undefined) { 3326 throw new Error('No method named "' + config + '"'); 3327 } 3328 data[config](); 3329 } 3330 }); 3331 } 3332 }, { 3333 key: 'VERSION', 3334 get: function get() { 3335 return VERSION; 3336 } 3337 }, { 3338 key: 'Default', 3339 get: function get() { 3340 return Default; 3341 } 3342 }, { 3343 key: 'NAME', 3344 get: function get() { 3345 return NAME; 3346 } 3347 }, { 3348 key: 'DATA_KEY', 3349 get: function get() { 3350 return DATA_KEY; 3351 } 3352 }, { 3353 key: 'Event', 3354 get: function get() { 3355 return Event; 3356 } 3357 }, { 3358 key: 'EVENT_KEY', 3359 get: function get() { 3360 return EVENT_KEY; 3361 } 3362 }, { 3363 key: 'DefaultType', 3364 get: function get() { 3365 return DefaultType; 3366 } 3367 }]); 3368 3369 return Tooltip; 3370 })(); 3371 3372 $.fn[NAME] = Tooltip._jQueryInterface; 3373 $.fn[NAME].Constructor = Tooltip; 3374 $.fn[NAME].noConflict = function () { 3375 $.fn[NAME] = JQUERY_NO_CONFLICT; 3376 return Tooltip._jQueryInterface; 3377 }; 3378 3379 return Tooltip; 3380})(jQuery); 3381 3382/** 3383 * -------------------------------------------------------------------------- 3384 * Bootstrap (v4.0.0-alpha.3): popover.js 3385 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 3386 * -------------------------------------------------------------------------- 3387 */ 3388 3389var Popover = (function ($) { 3390 3391 /** 3392 * ------------------------------------------------------------------------ 3393 * Constants 3394 * ------------------------------------------------------------------------ 3395 */ 3396 3397 var NAME = 'popover'; 3398 var VERSION = '4.0.0-alpha.3'; 3399 var DATA_KEY = 'bs.popover'; 3400 var EVENT_KEY = '.' + DATA_KEY; 3401 var JQUERY_NO_CONFLICT = $.fn[NAME]; 3402 3403 var Default = $.extend({}, Tooltip.Default, { 3404 placement: 'right', 3405 trigger: 'click', 3406 content: '', 3407 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-title"></h3>' + '<div class="popover-content"></div></div>' 3408 }); 3409 3410 var DefaultType = $.extend({}, Tooltip.DefaultType, { 3411 content: '(string|element|function)' 3412 }); 3413 3414 var ClassName = { 3415 FADE: 'fade', 3416 IN: 'in' 3417 }; 3418 3419 var Selector = { 3420 TITLE: '.popover-title', 3421 CONTENT: '.popover-content', 3422 ARROW: '.popover-arrow' 3423 }; 3424 3425 var Event = { 3426 HIDE: 'hide' + EVENT_KEY, 3427 HIDDEN: 'hidden' + EVENT_KEY, 3428 SHOW: 'show' + EVENT_KEY, 3429 SHOWN: 'shown' + EVENT_KEY, 3430 INSERTED: 'inserted' + EVENT_KEY, 3431 CLICK: 'click' + EVENT_KEY, 3432 FOCUSIN: 'focusin' + EVENT_KEY, 3433 FOCUSOUT: 'focusout' + EVENT_KEY, 3434 MOUSEENTER: 'mouseenter' + EVENT_KEY, 3435 MOUSELEAVE: 'mouseleave' + EVENT_KEY 3436 }; 3437 3438 /** 3439 * ------------------------------------------------------------------------ 3440 * Class Definition 3441 * ------------------------------------------------------------------------ 3442 */ 3443 3444 var Popover = (function (_Tooltip) {
3445 _inherits(Popover, _Tooltip); 3446 3447 function Popover() { 3448 _classCallCheck(this, Popover); 3449 3450 _get(Object.getPrototypeOf(Popover.prototype), 'constructor', this).apply(this, arguments); 3451 } 3452 3453 /** 3454 * ------------------------------------------------------------------------ 3455 * jQuery 3456 * ------------------------------------------------------------------------ 3457 */ 3458 3459 _createClass(Popover, [{ 3460 key: 'isWithContent', 3461 3462 // overrides 3463 3464 value: function isWithContent() { 3465 return this.getTitle() || this._getContent(); 3466 } 3467 }, { 3468 key: 'getTipElement', 3469 value: function getTipElement() { 3470 return this.tip = this.tip || $(this.config.template)[0]; 3471 } 3472 }, { 3473 key: 'setContent', 3474 value: function setContent() { 3475 var $tip = $(this.getTipElement()); 3476 3477 // we use append for html objects to maintain js events 3478 this.setElementContent($tip.find(Selector.TITLE), this.getTitle()); 3479 this.setElementContent($tip.find(Selector.CONTENT), this._getContent()); 3480 3481 $tip.removeClass(ClassName.FADE).removeClass(ClassName.IN); 3482 3483 this.cleanupTether(); 3484 } 3485 3486 // private 3487 3488 }, { 3489 key: '_getContent', 3490 value: function _getContent() { 3491 return this.element.getAttribute('data-content') || (typeof this.config.content === 'function' ? this.config.content.call(this.element) : this.config.content); 3492 } 3493 3494 // static 3495 3496 }], [{ 3497 key: '_jQueryInterface', 3498 value: function _jQueryInterface(config) { 3499 return this.each(function () { 3500 var data = $(this).data(DATA_KEY); 3501 var _config = typeof config === 'object' ? config : null; 3502 3503 if (!data && /destroy|hide/.test(config)) { 3504 return; 3505 } 3506 3507 if (!data) { 3508 data = new Popover(this, _config); 3509 $(this).data(DATA_KEY, data); 3510 } 3511 3512 if (typeof config === 'string') { 3513 if (data[config] === undefined) { 3514 throw new Error('No method named "' + config + '"'); 3515 } 3516 data[config](); 3517 } 3518 }); 3519 } 3520 }, { 3521 key: 'VERSION', 3522 3523 // getters 3524 3525 get: function get() { 3526 return VERSION; 3527 } 3528 }, { 3529 key: 'Default', 3530 get: function get() { 3531 return Default; 3532 } 3533 }, { 3534 key: 'NAME', 3535 get: function get() { 3536 return NAME; 3537 } 3538 }, { 3539 key: 'DATA_KEY', 3540 get: function get() { 3541 return DATA_KEY; 3542 } 3543 }, { 3544 key: 'Event', 3545 get: function get() { 3546 return Event; 3547 } 3548 }, { 3549 key: 'EVENT_KEY', 3550 get: function get() { 3551 return EVENT_KEY; 3552 } 3553 }, { 3554 key: 'DefaultType', 3555 get: function get() { 3556 return DefaultType; 3557 } 3558 }]); 3559 3560 return Popover; 3561 })(Tooltip); 3562 3563 $.fn[NAME] = Popover._jQueryInterface; 3564 $.fn[NAME].Constructor = Popover; 3565 $.fn[NAME].noConflict = function () { 3566 $.fn[NAME] = JQUERY_NO_CONFLICT; 3567 return Popover._jQueryInterface; 3568 }; 3569 3570 return Popover; 3571})(jQuery); 3572 3573}(jQuery);
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.