Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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