PageRenderTime 131ms CodeModel.GetById 19ms app.highlight 98ms RepoModel.GetById 1ms app.codeStats 1ms

/js/bootstrap.js

https://bitbucket.org/denissilva/cgpdi_admin
JavaScript | 3894 lines | 2797 code | 743 blank | 354 comment | 447 complexity | d810a38ca2781735a27cba0625a027db MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*!
   2  * Bootstrap v4.0.0 (https://getbootstrap.com)
   3  * Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
   4  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   5  */
   6(function (global, factory) {
   7	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) :
   8	typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) :
   9	(factory((global.bootstrap = {}),global.jQuery,global.Popper));
  10}(this, (function (exports,$,Popper) { 'use strict';
  11
  12$ = $ && $.hasOwnProperty('default') ? $['default'] : $;
  13Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
  14
  15function _defineProperties(target, props) {
  16  for (var i = 0; i < props.length; i++) {
  17    var descriptor = props[i];
  18    descriptor.enumerable = descriptor.enumerable || false;
  19    descriptor.configurable = true;
  20    if ("value" in descriptor) descriptor.writable = true;
  21    Object.defineProperty(target, descriptor.key, descriptor);
  22  }
  23}
  24
  25function _createClass(Constructor, protoProps, staticProps) {
  26  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  27  if (staticProps) _defineProperties(Constructor, staticProps);
  28  return Constructor;
  29}
  30
  31function _extends() {
  32  _extends = Object.assign || function (target) {
  33    for (var i = 1; i < arguments.length; i++) {
  34      var source = arguments[i];
  35
  36      for (var key in source) {
  37        if (Object.prototype.hasOwnProperty.call(source, key)) {
  38          target[key] = source[key];
  39        }
  40      }
  41    }
  42
  43    return target;
  44  };
  45
  46  return _extends.apply(this, arguments);
  47}
  48
  49function _inheritsLoose(subClass, superClass) {
  50  subClass.prototype = Object.create(superClass.prototype);
  51  subClass.prototype.constructor = subClass;
  52  subClass.__proto__ = superClass;
  53}
  54
  55/**
  56 * --------------------------------------------------------------------------
  57 * Bootstrap (v4.0.0): util.js
  58 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  59 * --------------------------------------------------------------------------
  60 */
  61
  62var Util = function ($$$1) {
  63  /**
  64   * ------------------------------------------------------------------------
  65   * Private TransitionEnd Helpers
  66   * ------------------------------------------------------------------------
  67   */
  68  var transition = false;
  69  var MAX_UID = 1000000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
  70
  71  function toType(obj) {
  72    return {}.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
  73  }
  74
  75  function getSpecialTransitionEndEvent() {
  76    return {
  77      bindType: transition.end,
  78      delegateType: transition.end,
  79      handle: function handle(event) {
  80        if ($$$1(event.target).is(this)) {
  81          return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
  82        }
  83
  84        return undefined; // eslint-disable-line no-undefined
  85      }
  86    };
  87  }
  88
  89  function transitionEndTest() {
  90    if (typeof window !== 'undefined' && window.QUnit) {
  91      return false;
  92    }
  93
  94    return {
  95      end: 'transitionend'
  96    };
  97  }
  98
  99  function transitionEndEmulator(duration) {
 100    var _this = this;
 101
 102    var called = false;
 103    $$$1(this).one(Util.TRANSITION_END, function () {
 104      called = true;
 105    });
 106    setTimeout(function () {
 107      if (!called) {
 108        Util.triggerTransitionEnd(_this);
 109      }
 110    }, duration);
 111    return this;
 112  }
 113
 114  function setTransitionEndSupport() {
 115    transition = transitionEndTest();
 116    $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
 117
 118    if (Util.supportsTransitionEnd()) {
 119      $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
 120    }
 121  }
 122
 123  function escapeId(selector) {
 124    // We escape IDs in case of special selectors (selector = '#myId:something')
 125    // $.escapeSelector does not exist in jQuery < 3
 126    selector = typeof $$$1.escapeSelector === 'function' ? $$$1.escapeSelector(selector).substr(1) : selector.replace(/(:|\.|\[|\]|,|=|@)/g, '\\$1');
 127    return selector;
 128  }
 129  /**
 130   * --------------------------------------------------------------------------
 131   * Public Util Api
 132   * --------------------------------------------------------------------------
 133   */
 134
 135
 136  var Util = {
 137    TRANSITION_END: 'bsTransitionEnd',
 138    getUID: function getUID(prefix) {
 139      do {
 140        // eslint-disable-next-line no-bitwise
 141        prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
 142      } while (document.getElementById(prefix));
 143
 144      return prefix;
 145    },
 146    getSelectorFromElement: function getSelectorFromElement(element) {
 147      var selector = element.getAttribute('data-target');
 148
 149      if (!selector || selector === '#') {
 150        selector = element.getAttribute('href') || '';
 151      } // If it's an ID
 152
 153
 154      if (selector.charAt(0) === '#') {
 155        selector = escapeId(selector);
 156      }
 157
 158      try {
 159        var $selector = $$$1(document).find(selector);
 160        return $selector.length > 0 ? selector : null;
 161      } catch (err) {
 162        return null;
 163      }
 164    },
 165    reflow: function reflow(element) {
 166      return element.offsetHeight;
 167    },
 168    triggerTransitionEnd: function triggerTransitionEnd(element) {
 169      $$$1(element).trigger(transition.end);
 170    },
 171    supportsTransitionEnd: function supportsTransitionEnd() {
 172      return Boolean(transition);
 173    },
 174    isElement: function isElement(obj) {
 175      return (obj[0] || obj).nodeType;
 176    },
 177    typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
 178      for (var property in configTypes) {
 179        if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
 180          var expectedTypes = configTypes[property];
 181          var value = config[property];
 182          var valueType = value && Util.isElement(value) ? 'element' : toType(value);
 183
 184          if (!new RegExp(expectedTypes).test(valueType)) {
 185            throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
 186          }
 187        }
 188      }
 189    }
 190  };
 191  setTransitionEndSupport();
 192  return Util;
 193}($);
 194
 195/**
 196 * --------------------------------------------------------------------------
 197 * Bootstrap (v4.0.0): alert.js
 198 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 199 * --------------------------------------------------------------------------
 200 */
 201
 202var Alert = function ($$$1) {
 203  /**
 204   * ------------------------------------------------------------------------
 205   * Constants
 206   * ------------------------------------------------------------------------
 207   */
 208  var NAME = 'alert';
 209  var VERSION = '4.0.0';
 210  var DATA_KEY = 'bs.alert';
 211  var EVENT_KEY = "." + DATA_KEY;
 212  var DATA_API_KEY = '.data-api';
 213  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 214  var TRANSITION_DURATION = 150;
 215  var Selector = {
 216    DISMISS: '[data-dismiss="alert"]'
 217  };
 218  var Event = {
 219    CLOSE: "close" + EVENT_KEY,
 220    CLOSED: "closed" + EVENT_KEY,
 221    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
 222  };
 223  var ClassName = {
 224    ALERT: 'alert',
 225    FADE: 'fade',
 226    SHOW: 'show'
 227    /**
 228     * ------------------------------------------------------------------------
 229     * Class Definition
 230     * ------------------------------------------------------------------------
 231     */
 232
 233  };
 234
 235  var Alert =
 236  /*#__PURE__*/
 237  function () {
 238    function Alert(element) {
 239      this._element = element;
 240    } // Getters
 241
 242
 243    var _proto = Alert.prototype;
 244
 245    // Public
 246    _proto.close = function close(element) {
 247      element = element || this._element;
 248
 249      var rootElement = this._getRootElement(element);
 250
 251      var customEvent = this._triggerCloseEvent(rootElement);
 252
 253      if (customEvent.isDefaultPrevented()) {
 254        return;
 255      }
 256
 257      this._removeElement(rootElement);
 258    };
 259
 260    _proto.dispose = function dispose() {
 261      $$$1.removeData(this._element, DATA_KEY);
 262      this._element = null;
 263    }; // Private
 264
 265
 266    _proto._getRootElement = function _getRootElement(element) {
 267      var selector = Util.getSelectorFromElement(element);
 268      var parent = false;
 269
 270      if (selector) {
 271        parent = $$$1(selector)[0];
 272      }
 273
 274      if (!parent) {
 275        parent = $$$1(element).closest("." + ClassName.ALERT)[0];
 276      }
 277
 278      return parent;
 279    };
 280
 281    _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
 282      var closeEvent = $$$1.Event(Event.CLOSE);
 283      $$$1(element).trigger(closeEvent);
 284      return closeEvent;
 285    };
 286
 287    _proto._removeElement = function _removeElement(element) {
 288      var _this = this;
 289
 290      $$$1(element).removeClass(ClassName.SHOW);
 291
 292      if (!Util.supportsTransitionEnd() || !$$$1(element).hasClass(ClassName.FADE)) {
 293        this._destroyElement(element);
 294
 295        return;
 296      }
 297
 298      $$$1(element).one(Util.TRANSITION_END, function (event) {
 299        return _this._destroyElement(element, event);
 300      }).emulateTransitionEnd(TRANSITION_DURATION);
 301    };
 302
 303    _proto._destroyElement = function _destroyElement(element) {
 304      $$$1(element).detach().trigger(Event.CLOSED).remove();
 305    }; // Static
 306
 307
 308    Alert._jQueryInterface = function _jQueryInterface(config) {
 309      return this.each(function () {
 310        var $element = $$$1(this);
 311        var data = $element.data(DATA_KEY);
 312
 313        if (!data) {
 314          data = new Alert(this);
 315          $element.data(DATA_KEY, data);
 316        }
 317
 318        if (config === 'close') {
 319          data[config](this);
 320        }
 321      });
 322    };
 323
 324    Alert._handleDismiss = function _handleDismiss(alertInstance) {
 325      return function (event) {
 326        if (event) {
 327          event.preventDefault();
 328        }
 329
 330        alertInstance.close(this);
 331      };
 332    };
 333
 334    _createClass(Alert, null, [{
 335      key: "VERSION",
 336      get: function get() {
 337        return VERSION;
 338      }
 339    }]);
 340    return Alert;
 341  }();
 342  /**
 343   * ------------------------------------------------------------------------
 344   * Data Api implementation
 345   * ------------------------------------------------------------------------
 346   */
 347
 348
 349  $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
 350  /**
 351   * ------------------------------------------------------------------------
 352   * jQuery
 353   * ------------------------------------------------------------------------
 354   */
 355
 356  $$$1.fn[NAME] = Alert._jQueryInterface;
 357  $$$1.fn[NAME].Constructor = Alert;
 358
 359  $$$1.fn[NAME].noConflict = function () {
 360    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
 361    return Alert._jQueryInterface;
 362  };
 363
 364  return Alert;
 365}($);
 366
 367/**
 368 * --------------------------------------------------------------------------
 369 * Bootstrap (v4.0.0): button.js
 370 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 371 * --------------------------------------------------------------------------
 372 */
 373
 374var Button = function ($$$1) {
 375  /**
 376   * ------------------------------------------------------------------------
 377   * Constants
 378   * ------------------------------------------------------------------------
 379   */
 380  var NAME = 'button';
 381  var VERSION = '4.0.0';
 382  var DATA_KEY = 'bs.button';
 383  var EVENT_KEY = "." + DATA_KEY;
 384  var DATA_API_KEY = '.data-api';
 385  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 386  var ClassName = {
 387    ACTIVE: 'active',
 388    BUTTON: 'btn',
 389    FOCUS: 'focus'
 390  };
 391  var Selector = {
 392    DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
 393    DATA_TOGGLE: '[data-toggle="buttons"]',
 394    INPUT: 'input',
 395    ACTIVE: '.active',
 396    BUTTON: '.btn'
 397  };
 398  var Event = {
 399    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
 400    FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
 401    /**
 402     * ------------------------------------------------------------------------
 403     * Class Definition
 404     * ------------------------------------------------------------------------
 405     */
 406
 407  };
 408
 409  var Button =
 410  /*#__PURE__*/
 411  function () {
 412    function Button(element) {
 413      this._element = element;
 414    } // Getters
 415
 416
 417    var _proto = Button.prototype;
 418
 419    // Public
 420    _proto.toggle = function toggle() {
 421      var triggerChangeEvent = true;
 422      var addAriaPressed = true;
 423      var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
 424
 425      if (rootElement) {
 426        var input = $$$1(this._element).find(Selector.INPUT)[0];
 427
 428        if (input) {
 429          if (input.type === 'radio') {
 430            if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
 431              triggerChangeEvent = false;
 432            } else {
 433              var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
 434
 435              if (activeElement) {
 436                $$$1(activeElement).removeClass(ClassName.ACTIVE);
 437              }
 438            }
 439          }
 440
 441          if (triggerChangeEvent) {
 442            if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
 443              return;
 444            }
 445
 446            input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
 447            $$$1(input).trigger('change');
 448          }
 449
 450          input.focus();
 451          addAriaPressed = false;
 452        }
 453      }
 454
 455      if (addAriaPressed) {
 456        this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
 457      }
 458
 459      if (triggerChangeEvent) {
 460        $$$1(this._element).toggleClass(ClassName.ACTIVE);
 461      }
 462    };
 463
 464    _proto.dispose = function dispose() {
 465      $$$1.removeData(this._element, DATA_KEY);
 466      this._element = null;
 467    }; // Static
 468
 469
 470    Button._jQueryInterface = function _jQueryInterface(config) {
 471      return this.each(function () {
 472        var data = $$$1(this).data(DATA_KEY);
 473
 474        if (!data) {
 475          data = new Button(this);
 476          $$$1(this).data(DATA_KEY, data);
 477        }
 478
 479        if (config === 'toggle') {
 480          data[config]();
 481        }
 482      });
 483    };
 484
 485    _createClass(Button, null, [{
 486      key: "VERSION",
 487      get: function get() {
 488        return VERSION;
 489      }
 490    }]);
 491    return Button;
 492  }();
 493  /**
 494   * ------------------------------------------------------------------------
 495   * Data Api implementation
 496   * ------------------------------------------------------------------------
 497   */
 498
 499
 500  $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
 501    event.preventDefault();
 502    var button = event.target;
 503
 504    if (!$$$1(button).hasClass(ClassName.BUTTON)) {
 505      button = $$$1(button).closest(Selector.BUTTON);
 506    }
 507
 508    Button._jQueryInterface.call($$$1(button), 'toggle');
 509  }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
 510    var button = $$$1(event.target).closest(Selector.BUTTON)[0];
 511    $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
 512  });
 513  /**
 514   * ------------------------------------------------------------------------
 515   * jQuery
 516   * ------------------------------------------------------------------------
 517   */
 518
 519  $$$1.fn[NAME] = Button._jQueryInterface;
 520  $$$1.fn[NAME].Constructor = Button;
 521
 522  $$$1.fn[NAME].noConflict = function () {
 523    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
 524    return Button._jQueryInterface;
 525  };
 526
 527  return Button;
 528}($);
 529
 530/**
 531 * --------------------------------------------------------------------------
 532 * Bootstrap (v4.0.0): carousel.js
 533 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 534 * --------------------------------------------------------------------------
 535 */
 536
 537var Carousel = function ($$$1) {
 538  /**
 539   * ------------------------------------------------------------------------
 540   * Constants
 541   * ------------------------------------------------------------------------
 542   */
 543  var NAME = 'carousel';
 544  var VERSION = '4.0.0';
 545  var DATA_KEY = 'bs.carousel';
 546  var EVENT_KEY = "." + DATA_KEY;
 547  var DATA_API_KEY = '.data-api';
 548  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
 549  var TRANSITION_DURATION = 600;
 550  var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
 551
 552  var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
 553
 554  var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
 555
 556  var Default = {
 557    interval: 5000,
 558    keyboard: true,
 559    slide: false,
 560    pause: 'hover',
 561    wrap: true
 562  };
 563  var DefaultType = {
 564    interval: '(number|boolean)',
 565    keyboard: 'boolean',
 566    slide: '(boolean|string)',
 567    pause: '(string|boolean)',
 568    wrap: 'boolean'
 569  };
 570  var Direction = {
 571    NEXT: 'next',
 572    PREV: 'prev',
 573    LEFT: 'left',
 574    RIGHT: 'right'
 575  };
 576  var Event = {
 577    SLIDE: "slide" + EVENT_KEY,
 578    SLID: "slid" + EVENT_KEY,
 579    KEYDOWN: "keydown" + EVENT_KEY,
 580    MOUSEENTER: "mouseenter" + EVENT_KEY,
 581    MOUSELEAVE: "mouseleave" + EVENT_KEY,
 582    TOUCHEND: "touchend" + EVENT_KEY,
 583    LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
 584    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
 585  };
 586  var ClassName = {
 587    CAROUSEL: 'carousel',
 588    ACTIVE: 'active',
 589    SLIDE: 'slide',
 590    RIGHT: 'carousel-item-right',
 591    LEFT: 'carousel-item-left',
 592    NEXT: 'carousel-item-next',
 593    PREV: 'carousel-item-prev',
 594    ITEM: 'carousel-item'
 595  };
 596  var Selector = {
 597    ACTIVE: '.active',
 598    ACTIVE_ITEM: '.active.carousel-item',
 599    ITEM: '.carousel-item',
 600    NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
 601    INDICATORS: '.carousel-indicators',
 602    DATA_SLIDE: '[data-slide], [data-slide-to]',
 603    DATA_RIDE: '[data-ride="carousel"]'
 604    /**
 605     * ------------------------------------------------------------------------
 606     * Class Definition
 607     * ------------------------------------------------------------------------
 608     */
 609
 610  };
 611
 612  var Carousel =
 613  /*#__PURE__*/
 614  function () {
 615    function Carousel(element, config) {
 616      this._items = null;
 617      this._interval = null;
 618      this._activeElement = null;
 619      this._isPaused = false;
 620      this._isSliding = false;
 621      this.touchTimeout = null;
 622      this._config = this._getConfig(config);
 623      this._element = $$$1(element)[0];
 624      this._indicatorsElement = $$$1(this._element).find(Selector.INDICATORS)[0];
 625
 626      this._addEventListeners();
 627    } // Getters
 628
 629
 630    var _proto = Carousel.prototype;
 631
 632    // Public
 633    _proto.next = function next() {
 634      if (!this._isSliding) {
 635        this._slide(Direction.NEXT);
 636      }
 637    };
 638
 639    _proto.nextWhenVisible = function nextWhenVisible() {
 640      // Don't call next when the page isn't visible
 641      // or the carousel or its parent isn't visible
 642      if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
 643        this.next();
 644      }
 645    };
 646
 647    _proto.prev = function prev() {
 648      if (!this._isSliding) {
 649        this._slide(Direction.PREV);
 650      }
 651    };
 652
 653    _proto.pause = function pause(event) {
 654      if (!event) {
 655        this._isPaused = true;
 656      }
 657
 658      if ($$$1(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) {
 659        Util.triggerTransitionEnd(this._element);
 660        this.cycle(true);
 661      }
 662
 663      clearInterval(this._interval);
 664      this._interval = null;
 665    };
 666
 667    _proto.cycle = function cycle(event) {
 668      if (!event) {
 669        this._isPaused = false;
 670      }
 671
 672      if (this._interval) {
 673        clearInterval(this._interval);
 674        this._interval = null;
 675      }
 676
 677      if (this._config.interval && !this._isPaused) {
 678        this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
 679      }
 680    };
 681
 682    _proto.to = function to(index) {
 683      var _this = this;
 684
 685      this._activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
 686
 687      var activeIndex = this._getItemIndex(this._activeElement);
 688
 689      if (index > this._items.length - 1 || index < 0) {
 690        return;
 691      }
 692
 693      if (this._isSliding) {
 694        $$$1(this._element).one(Event.SLID, function () {
 695          return _this.to(index);
 696        });
 697        return;
 698      }
 699
 700      if (activeIndex === index) {
 701        this.pause();
 702        this.cycle();
 703        return;
 704      }
 705
 706      var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
 707
 708      this._slide(direction, this._items[index]);
 709    };
 710
 711    _proto.dispose = function dispose() {
 712      $$$1(this._element).off(EVENT_KEY);
 713      $$$1.removeData(this._element, DATA_KEY);
 714      this._items = null;
 715      this._config = null;
 716      this._element = null;
 717      this._interval = null;
 718      this._isPaused = null;
 719      this._isSliding = null;
 720      this._activeElement = null;
 721      this._indicatorsElement = null;
 722    }; // Private
 723
 724
 725    _proto._getConfig = function _getConfig(config) {
 726      config = _extends({}, Default, config);
 727      Util.typeCheckConfig(NAME, config, DefaultType);
 728      return config;
 729    };
 730
 731    _proto._addEventListeners = function _addEventListeners() {
 732      var _this2 = this;
 733
 734      if (this._config.keyboard) {
 735        $$$1(this._element).on(Event.KEYDOWN, function (event) {
 736          return _this2._keydown(event);
 737        });
 738      }
 739
 740      if (this._config.pause === 'hover') {
 741        $$$1(this._element).on(Event.MOUSEENTER, function (event) {
 742          return _this2.pause(event);
 743        }).on(Event.MOUSELEAVE, function (event) {
 744          return _this2.cycle(event);
 745        });
 746
 747        if ('ontouchstart' in document.documentElement) {
 748          // If it's a touch-enabled device, mouseenter/leave are fired as
 749          // part of the mouse compatibility events on first tap - the carousel
 750          // would stop cycling until user tapped out of it;
 751          // here, we listen for touchend, explicitly pause the carousel
 752          // (as if it's the second time we tap on it, mouseenter compat event
 753          // is NOT fired) and after a timeout (to allow for mouse compatibility
 754          // events to fire) we explicitly restart cycling
 755          $$$1(this._element).on(Event.TOUCHEND, function () {
 756            _this2.pause();
 757
 758            if (_this2.touchTimeout) {
 759              clearTimeout(_this2.touchTimeout);
 760            }
 761
 762            _this2.touchTimeout = setTimeout(function (event) {
 763              return _this2.cycle(event);
 764            }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
 765          });
 766        }
 767      }
 768    };
 769
 770    _proto._keydown = function _keydown(event) {
 771      if (/input|textarea/i.test(event.target.tagName)) {
 772        return;
 773      }
 774
 775      switch (event.which) {
 776        case ARROW_LEFT_KEYCODE:
 777          event.preventDefault();
 778          this.prev();
 779          break;
 780
 781        case ARROW_RIGHT_KEYCODE:
 782          event.preventDefault();
 783          this.next();
 784          break;
 785
 786        default:
 787      }
 788    };
 789
 790    _proto._getItemIndex = function _getItemIndex(element) {
 791      this._items = $$$1.makeArray($$$1(element).parent().find(Selector.ITEM));
 792      return this._items.indexOf(element);
 793    };
 794
 795    _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
 796      var isNextDirection = direction === Direction.NEXT;
 797      var isPrevDirection = direction === Direction.PREV;
 798
 799      var activeIndex = this._getItemIndex(activeElement);
 800
 801      var lastItemIndex = this._items.length - 1;
 802      var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
 803
 804      if (isGoingToWrap && !this._config.wrap) {
 805        return activeElement;
 806      }
 807
 808      var delta = direction === Direction.PREV ? -1 : 1;
 809      var itemIndex = (activeIndex + delta) % this._items.length;
 810      return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
 811    };
 812
 813    _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
 814      var targetIndex = this._getItemIndex(relatedTarget);
 815
 816      var fromIndex = this._getItemIndex($$$1(this._element).find(Selector.ACTIVE_ITEM)[0]);
 817
 818      var slideEvent = $$$1.Event(Event.SLIDE, {
 819        relatedTarget: relatedTarget,
 820        direction: eventDirectionName,
 821        from: fromIndex,
 822        to: targetIndex
 823      });
 824      $$$1(this._element).trigger(slideEvent);
 825      return slideEvent;
 826    };
 827
 828    _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
 829      if (this._indicatorsElement) {
 830        $$$1(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
 831
 832        var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
 833
 834        if (nextIndicator) {
 835          $$$1(nextIndicator).addClass(ClassName.ACTIVE);
 836        }
 837      }
 838    };
 839
 840    _proto._slide = function _slide(direction, element) {
 841      var _this3 = this;
 842
 843      var activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
 844
 845      var activeElementIndex = this._getItemIndex(activeElement);
 846
 847      var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
 848
 849      var nextElementIndex = this._getItemIndex(nextElement);
 850
 851      var isCycling = Boolean(this._interval);
 852      var directionalClassName;
 853      var orderClassName;
 854      var eventDirectionName;
 855
 856      if (direction === Direction.NEXT) {
 857        directionalClassName = ClassName.LEFT;
 858        orderClassName = ClassName.NEXT;
 859        eventDirectionName = Direction.LEFT;
 860      } else {
 861        directionalClassName = ClassName.RIGHT;
 862        orderClassName = ClassName.PREV;
 863        eventDirectionName = Direction.RIGHT;
 864      }
 865
 866      if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
 867        this._isSliding = false;
 868        return;
 869      }
 870
 871      var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
 872
 873      if (slideEvent.isDefaultPrevented()) {
 874        return;
 875      }
 876
 877      if (!activeElement || !nextElement) {
 878        // Some weirdness is happening, so we bail
 879        return;
 880      }
 881
 882      this._isSliding = true;
 883
 884      if (isCycling) {
 885        this.pause();
 886      }
 887
 888      this._setActiveIndicatorElement(nextElement);
 889
 890      var slidEvent = $$$1.Event(Event.SLID, {
 891        relatedTarget: nextElement,
 892        direction: eventDirectionName,
 893        from: activeElementIndex,
 894        to: nextElementIndex
 895      });
 896
 897      if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.SLIDE)) {
 898        $$$1(nextElement).addClass(orderClassName);
 899        Util.reflow(nextElement);
 900        $$$1(activeElement).addClass(directionalClassName);
 901        $$$1(nextElement).addClass(directionalClassName);
 902        $$$1(activeElement).one(Util.TRANSITION_END, function () {
 903          $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
 904          $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
 905          _this3._isSliding = false;
 906          setTimeout(function () {
 907            return $$$1(_this3._element).trigger(slidEvent);
 908          }, 0);
 909        }).emulateTransitionEnd(TRANSITION_DURATION);
 910      } else {
 911        $$$1(activeElement).removeClass(ClassName.ACTIVE);
 912        $$$1(nextElement).addClass(ClassName.ACTIVE);
 913        this._isSliding = false;
 914        $$$1(this._element).trigger(slidEvent);
 915      }
 916
 917      if (isCycling) {
 918        this.cycle();
 919      }
 920    }; // Static
 921
 922
 923    Carousel._jQueryInterface = function _jQueryInterface(config) {
 924      return this.each(function () {
 925        var data = $$$1(this).data(DATA_KEY);
 926
 927        var _config = _extends({}, Default, $$$1(this).data());
 928
 929        if (typeof config === 'object') {
 930          _config = _extends({}, _config, config);
 931        }
 932
 933        var action = typeof config === 'string' ? config : _config.slide;
 934
 935        if (!data) {
 936          data = new Carousel(this, _config);
 937          $$$1(this).data(DATA_KEY, data);
 938        }
 939
 940        if (typeof config === 'number') {
 941          data.to(config);
 942        } else if (typeof action === 'string') {
 943          if (typeof data[action] === 'undefined') {
 944            throw new TypeError("No method named \"" + action + "\"");
 945          }
 946
 947          data[action]();
 948        } else if (_config.interval) {
 949          data.pause();
 950          data.cycle();
 951        }
 952      });
 953    };
 954
 955    Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
 956      var selector = Util.getSelectorFromElement(this);
 957
 958      if (!selector) {
 959        return;
 960      }
 961
 962      var target = $$$1(selector)[0];
 963
 964      if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
 965        return;
 966      }
 967
 968      var config = _extends({}, $$$1(target).data(), $$$1(this).data());
 969      var slideIndex = this.getAttribute('data-slide-to');
 970
 971      if (slideIndex) {
 972        config.interval = false;
 973      }
 974
 975      Carousel._jQueryInterface.call($$$1(target), config);
 976
 977      if (slideIndex) {
 978        $$$1(target).data(DATA_KEY).to(slideIndex);
 979      }
 980
 981      event.preventDefault();
 982    };
 983
 984    _createClass(Carousel, null, [{
 985      key: "VERSION",
 986      get: function get() {
 987        return VERSION;
 988      }
 989    }, {
 990      key: "Default",
 991      get: function get() {
 992        return Default;
 993      }
 994    }]);
 995    return Carousel;
 996  }();
 997  /**
 998   * ------------------------------------------------------------------------
 999   * Data Api implementation
1000   * ------------------------------------------------------------------------
1001   */
1002
1003
1004  $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
1005  $$$1(window).on(Event.LOAD_DATA_API, function () {
1006    $$$1(Selector.DATA_RIDE).each(function () {
1007      var $carousel = $$$1(this);
1008
1009      Carousel._jQueryInterface.call($carousel, $carousel.data());
1010    });
1011  });
1012  /**
1013   * ------------------------------------------------------------------------
1014   * jQuery
1015   * ------------------------------------------------------------------------
1016   */
1017
1018  $$$1.fn[NAME] = Carousel._jQueryInterface;
1019  $$$1.fn[NAME].Constructor = Carousel;
1020
1021  $$$1.fn[NAME].noConflict = function () {
1022    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1023    return Carousel._jQueryInterface;
1024  };
1025
1026  return Carousel;
1027}($);
1028
1029/**
1030 * --------------------------------------------------------------------------
1031 * Bootstrap (v4.0.0): collapse.js
1032 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1033 * --------------------------------------------------------------------------
1034 */
1035
1036var Collapse = function ($$$1) {
1037  /**
1038   * ------------------------------------------------------------------------
1039   * Constants
1040   * ------------------------------------------------------------------------
1041   */
1042  var NAME = 'collapse';
1043  var VERSION = '4.0.0';
1044  var DATA_KEY = 'bs.collapse';
1045  var EVENT_KEY = "." + DATA_KEY;
1046  var DATA_API_KEY = '.data-api';
1047  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1048  var TRANSITION_DURATION = 600;
1049  var Default = {
1050    toggle: true,
1051    parent: ''
1052  };
1053  var DefaultType = {
1054    toggle: 'boolean',
1055    parent: '(string|element)'
1056  };
1057  var Event = {
1058    SHOW: "show" + EVENT_KEY,
1059    SHOWN: "shown" + EVENT_KEY,
1060    HIDE: "hide" + EVENT_KEY,
1061    HIDDEN: "hidden" + EVENT_KEY,
1062    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
1063  };
1064  var ClassName = {
1065    SHOW: 'show',
1066    COLLAPSE: 'collapse',
1067    COLLAPSING: 'collapsing',
1068    COLLAPSED: 'collapsed'
1069  };
1070  var Dimension = {
1071    WIDTH: 'width',
1072    HEIGHT: 'height'
1073  };
1074  var Selector = {
1075    ACTIVES: '.show, .collapsing',
1076    DATA_TOGGLE: '[data-toggle="collapse"]'
1077    /**
1078     * ------------------------------------------------------------------------
1079     * Class Definition
1080     * ------------------------------------------------------------------------
1081     */
1082
1083  };
1084
1085  var Collapse =
1086  /*#__PURE__*/
1087  function () {
1088    function Collapse(element, config) {
1089      this._isTransitioning = false;
1090      this._element = element;
1091      this._config = this._getConfig(config);
1092      this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
1093      var tabToggles = $$$1(Selector.DATA_TOGGLE);
1094
1095      for (var i = 0; i < tabToggles.length; i++) {
1096        var elem = tabToggles[i];
1097        var selector = Util.getSelectorFromElement(elem);
1098
1099        if (selector !== null && $$$1(selector).filter(element).length > 0) {
1100          this._selector = selector;
1101
1102          this._triggerArray.push(elem);
1103        }
1104      }
1105
1106      this._parent = this._config.parent ? this._getParent() : null;
1107
1108      if (!this._config.parent) {
1109        this._addAriaAndCollapsedClass(this._element, this._triggerArray);
1110      }
1111
1112      if (this._config.toggle) {
1113        this.toggle();
1114      }
1115    } // Getters
1116
1117
1118    var _proto = Collapse.prototype;
1119
1120    // Public
1121    _proto.toggle = function toggle() {
1122      if ($$$1(this._element).hasClass(ClassName.SHOW)) {
1123        this.hide();
1124      } else {
1125        this.show();
1126      }
1127    };
1128
1129    _proto.show = function show() {
1130      var _this = this;
1131
1132      if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
1133        return;
1134      }
1135
1136      var actives;
1137      var activesData;
1138
1139      if (this._parent) {
1140        actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
1141
1142        if (actives.length === 0) {
1143          actives = null;
1144        }
1145      }
1146
1147      if (actives) {
1148        activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
1149
1150        if (activesData && activesData._isTransitioning) {
1151          return;
1152        }
1153      }
1154
1155      var startEvent = $$$1.Event(Event.SHOW);
1156      $$$1(this._element).trigger(startEvent);
1157
1158      if (startEvent.isDefaultPrevented()) {
1159        return;
1160      }
1161
1162      if (actives) {
1163        Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
1164
1165        if (!activesData) {
1166          $$$1(actives).data(DATA_KEY, null);
1167        }
1168      }
1169
1170      var dimension = this._getDimension();
1171
1172      $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
1173      this._element.style[dimension] = 0;
1174
1175      if (this._triggerArray.length > 0) {
1176        $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
1177      }
1178
1179      this.setTransitioning(true);
1180
1181      var complete = function complete() {
1182        $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
1183        _this._element.style[dimension] = '';
1184
1185        _this.setTransitioning(false);
1186
1187        $$$1(_this._element).trigger(Event.SHOWN);
1188      };
1189
1190      if (!Util.supportsTransitionEnd()) {
1191        complete();
1192        return;
1193      }
1194
1195      var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1196      var scrollSize = "scroll" + capitalizedDimension;
1197      $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
1198      this._element.style[dimension] = this._element[scrollSize] + "px";
1199    };
1200
1201    _proto.hide = function hide() {
1202      var _this2 = this;
1203
1204      if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
1205        return;
1206      }
1207
1208      var startEvent = $$$1.Event(Event.HIDE);
1209      $$$1(this._element).trigger(startEvent);
1210
1211      if (startEvent.isDefaultPrevented()) {
1212        return;
1213      }
1214
1215      var dimension = this._getDimension();
1216
1217      this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
1218      Util.reflow(this._element);
1219      $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
1220
1221      if (this._triggerArray.length > 0) {
1222        for (var i = 0; i < this._triggerArray.length; i++) {
1223          var trigger = this._triggerArray[i];
1224          var selector = Util.getSelectorFromElement(trigger);
1225
1226          if (selector !== null) {
1227            var $elem = $$$1(selector);
1228
1229            if (!$elem.hasClass(ClassName.SHOW)) {
1230              $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
1231            }
1232          }
1233        }
1234      }
1235
1236      this.setTransitioning(true);
1237
1238      var complete = function complete() {
1239        _this2.setTransitioning(false);
1240
1241        $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
1242      };
1243
1244      this._element.style[dimension] = '';
1245
1246      if (!Util.supportsTransitionEnd()) {
1247        complete();
1248        return;
1249      }
1250
1251      $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
1252    };
1253
1254    _proto.setTransitioning = function setTransitioning(isTransitioning) {
1255      this._isTransitioning = isTransitioning;
1256    };
1257
1258    _proto.dispose = function dispose() {
1259      $$$1.removeData(this._element, DATA_KEY);
1260      this._config = null;
1261      this._parent = null;
1262      this._element = null;
1263      this._triggerArray = null;
1264      this._isTransitioning = null;
1265    }; // Private
1266
1267
1268    _proto._getConfig = function _getConfig(config) {
1269      config = _extends({}, Default, config);
1270      config.toggle = Boolean(config.toggle); // Coerce string values
1271
1272      Util.typeCheckConfig(NAME, config, DefaultType);
1273      return config;
1274    };
1275
1276    _proto._getDimension = function _getDimension() {
1277      var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
1278      return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
1279    };
1280
1281    _proto._getParent = function _getParent() {
1282      var _this3 = this;
1283
1284      var parent = null;
1285
1286      if (Util.isElement(this._config.parent)) {
1287        parent = this._config.parent; // It's a jQuery object
1288
1289        if (typeof this._config.parent.jquery !== 'undefined') {
1290          parent = this._config.parent[0];
1291        }
1292      } else {
1293        parent = $$$1(this._config.parent)[0];
1294      }
1295
1296      var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
1297      $$$1(parent).find(selector).each(function (i, element) {
1298        _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
1299      });
1300      return parent;
1301    };
1302
1303    _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
1304      if (element) {
1305        var isOpen = $$$1(element).hasClass(ClassName.SHOW);
1306
1307        if (triggerArray.length > 0) {
1308          $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
1309        }
1310      }
1311    }; // Static
1312
1313
1314    Collapse._getTargetFromElement = function _getTargetFromElement(element) {
1315      var selector = Util.getSelectorFromElement(element);
1316      return selector ? $$$1(selector)[0] : null;
1317    };
1318
1319    Collapse._jQueryInterface = function _jQueryInterface(config) {
1320      return this.each(function () {
1321        var $this = $$$1(this);
1322        var data = $this.data(DATA_KEY);
1323
1324        var _config = _extends({}, Default, $this.data(), typeof config === 'object' && config);
1325
1326        if (!data && _config.toggle && /show|hide/.test(config)) {
1327          _config.toggle = false;
1328        }
1329
1330        if (!data) {
1331          data = new Collapse(this, _config);
1332          $this.data(DATA_KEY, data);
1333        }
1334
1335        if (typeof config === 'string') {
1336          if (typeof data[config] === 'undefined') {
1337            throw new TypeError("No method named \"" + config + "\"");
1338          }
1339
1340          data[config]();
1341        }
1342      });
1343    };
1344
1345    _createClass(Collapse, null, [{
1346      key: "VERSION",
1347      get: function get() {
1348        return VERSION;
1349      }
1350    }, {
1351      key: "Default",
1352      get: function get() {
1353        return Default;
1354      }
1355    }]);
1356    return Collapse;
1357  }();
1358  /**
1359   * ------------------------------------------------------------------------
1360   * Data Api implementation
1361   * ------------------------------------------------------------------------
1362   */
1363
1364
1365  $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
1366    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1367    if (event.currentTarget.tagName === 'A') {
1368      event.preventDefault();
1369    }
1370
1371    var $trigger = $$$1(this);
1372    var selector = Util.getSelectorFromElement(this);
1373    $$$1(selector).each(function () {
1374      var $target = $$$1(this);
1375      var data = $target.data(DATA_KEY);
1376      var config = data ? 'toggle' : $trigger.data();
1377
1378      Collapse._jQueryInterface.call($target, config);
1379    });
1380  });
1381  /**
1382   * ------------------------------------------------------------------------
1383   * jQuery
1384   * ------------------------------------------------------------------------
1385   */
1386
1387  $$$1.fn[NAME] = Collapse._jQueryInterface;
1388  $$$1.fn[NAME].Constructor = Collapse;
1389
1390  $$$1.fn[NAME].noConflict = function () {
1391    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1392    return Collapse._jQueryInterface;
1393  };
1394
1395  return Collapse;
1396}($);
1397
1398/**
1399 * --------------------------------------------------------------------------
1400 * Bootstrap (v4.0.0): dropdown.js
1401 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1402 * --------------------------------------------------------------------------
1403 */
1404
1405var Dropdown = function ($$$1) {
1406  /**
1407   * ------------------------------------------------------------------------
1408   * Constants
1409   * ------------------------------------------------------------------------
1410   */
1411  var NAME = 'dropdown';
1412  var VERSION = '4.0.0';
1413  var DATA_KEY = 'bs.dropdown';
1414  var EVENT_KEY = "." + DATA_KEY;
1415  var DATA_API_KEY = '.data-api';
1416  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1417  var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
1418
1419  var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
1420
1421  var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
1422
1423  var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
1424
1425  var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
1426
1427  var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
1428
1429  var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
1430  var Event = {
1431    HIDE: "hide" + EVENT_KEY,
1432    HIDDEN: "hidden" + EVENT_KEY,
1433    SHOW: "show" + EVENT_KEY,
1434    SHOWN: "shown" + EVENT_KEY,
1435    CLICK: "click" + EVENT_KEY,
1436    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
1437    KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
1438    KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY
1439  };
1440  var ClassName = {
1441    DISABLED: 'disabled',
1442    SHOW: 'show',
1443    DROPUP: 'dropup',
1444    DROPRIGHT: 'dropright',
1445    DROPLEFT: 'dropleft',
1446    MENURIGHT: 'dropdown-menu-right',
1447    MENULEFT: 'dropdown-menu-left',
1448    POSITION_STATIC: 'position-static'
1449  };
1450  var Selector = {
1451    DATA_TOGGLE: '[data-toggle="dropdown"]',
1452    FORM_CHILD: '.dropdown form',
1453    MENU: '.dropdown-menu',
1454    NAVBAR_NAV: '.navbar-nav',
1455    VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled)'
1456  };
1457  var AttachmentMap = {
1458    TOP: 'top-start',
1459    TOPEND: 'top-end',
1460    BOTTOM: 'bottom-start',
1461    BOTTOMEND: 'bottom-end',
1462    RIGHT: 'right-start',
1463    RIGHTEND: 'right-end',
1464    LEFT: 'left-start',
1465    LEFTEND: 'left-end'
1466  };
1467  var Default = {
1468    offset: 0,
1469    flip: true,
1470    boundary: 'scrollParent'
1471  };
1472  var DefaultType = {
1473    offset: '(number|string|function)',
1474    flip: 'boolean',
1475    boundary: '(string|element)'
1476    /**
1477     * ------------------------------------------------------------------------
1478     * Class Definition
1479     * ------------------------------------------------------------------------
1480     */
1481
1482  };
1483
1484  var Dropdown =
1485  /*#__PURE__*/
1486  function () {
1487    function Dropdown(element, config) {
1488      this._element = element;
1489      this._popper = null;
1490      this._config = this._getConfig(config);
1491      this._menu = this._getMenuElement();
1492      this._inNavbar = this._detectNavbar();
1493
1494      this._addEventListeners();
1495    } // Getters
1496
1497
1498    var _proto = Dropdown.prototype;
1499
1500    // Public
1501    _proto.toggle = function toggle() {
1502      if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
1503        return;
1504      }
1505
1506      var parent = Dropdown._getParentFromElement(this._element);
1507
1508      var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
1509
1510      Dropdown._clearMenus();
1511
1512      if (isActive) {
1513        return;
1514      }
1515
1516      var relatedTarget = {
1517        relatedTarget: this._element
1518      };
1519      var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
1520      $$$1(parent).trigger(showEvent);
1521
1522      if (showEvent.isDefaultPrevented()) {
1523        return;
1524      } // Disable totally Popper.js for Dropdown in Navbar
1525
1526
1527      if (!this._inNavbar) {
1528        /**
1529         * Check for Popper dependency
1530         * Popper - https://popper.js.org
1531         */
1532        if (typeof Popper === 'undefined') {
1533          throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
1534        }
1535
1536        var element = this._element; // For dropup with alignment we use the parent as popper container
1537
1538        if ($$$1(parent).hasClass(ClassName.DROPUP)) {
1539          if ($$$1(this._menu).hasClass(ClassName.MENULEFT) || $$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1540            element = parent;
1541          }
1542        } // If boundary is not `scrollParent`, then set position to `static`
1543        // to allow the menu to "escape" the scroll parent's boundaries
1544        // https://github.com/twbs/bootstrap/issues/24251
1545
1546
1547        if (this._config.boundary !== 'scrollParent') {
1548          $$$1(parent).addClass(ClassName.POSITION_STATIC);
1549        }
1550
1551        this._popper = new Popper(element, this._menu, this._getPopperConfig());
1552      } // If this is a touch-enabled device we add extra
1553      // empty mouseover listeners to the body's immediate children;
1554      // only needed because of broken event delegation on iOS
1555      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
1556
1557
1558      if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
1559        $$$1('body').children().on('mouseover', null, $$$1.noop);
1560      }
1561
1562      this._element.focus();
1563
1564      this._element.setAttribute('aria-expanded', true);
1565
1566      $$$1(this._menu).toggleClass(ClassName.SHOW);
1567      $$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
1568    };
1569
1570    _proto.dispose = function dispose() {
1571      $$$1.removeData(this._element, DATA_KEY);
1572      $$$1(this._element).off(EVENT_KEY);
1573      this._element = null;
1574      this._menu = null;
1575
1576      if (this._popper !== null) {
1577        this._popper.destroy();
1578
1579        this._popper = null;
1580      }
1581    };
1582
1583    _proto.update = function update() {
1584      this._inNavbar = this._detectNavbar();
1585
1586      if (this._popper !== null) {
1587        this._popper.scheduleUpdate();
1588      }
1589    }; // Private
1590
1591
1592    _proto._addEventListeners = function _addEventListeners() {
1593      var _this = this;
1594
1595      $$$1(this._element).on(Event.CLICK, function (event) {
1596        event.preventDefault();
1597        event.stopPropagation();
1598
1599        _this.toggle();
1600      });
1601    };
1602
1603    _proto._getConfig = function _getConfig(config) {
1604      config = _extends({}, this.constructor.Default, $$$1(this._element).data(), config);
1605      Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
1606      return config;
1607    };
1608
1609    _proto._getMenuElement = function _getMenuElement() {
1610      if (!this._menu) {
1611        var parent = Dropdown._getParentFromElement(this._element);
1612
1613        this._menu = $$$1(parent).find(Selector.MENU)[0];
1614      }
1615
1616      return this._menu;
1617    };
1618
1619    _proto._getPlacement = function _getPlacement() {
1620      var $parentDropdown = $$$1(this._element).parent();
1621      var placement = AttachmentMap.BOTTOM; // Handle dropup
1622
1623      if ($parentDropdown.hasClass(ClassName.DROPUP)) {
1624        placement = AttachmentMap.TOP;
1625
1626        if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1627          placement = AttachmentMap.TOPEND;
1628        }
1629      } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
1630        placement = AttachmentMap.RIGHT;
1631      } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
1632        placement = AttachmentMap.LEFT;
1633      } else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1634        placement = AttachmentMap.BOTTOMEND;
1635      }
1636
1637      return placement;
1638    };
1639
1640    _proto._detectNavbar = function _detectNavbar() {
1641      return $$$1(this._element).closest('.navbar').length > 0;
1642    };
1643
1644    _proto._getPopperConfig = function _getPopperConfig() {
1645      var _this2 = this;
1646
1647      var offsetConf = {};
1648
1649      if (typeof this._config.offset === 'function') {
1650        offsetConf.fn = function (data) {
1651          data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets) || {});
1652          return data;
1653        };
1654      } else {
1655        offsetConf.offset = this._config.offset;
1656      }
1657
1658      var popperConfig = {
1659        placement: this._getPlacement(),
1660        modifiers: {
1661          offset: offsetConf,
1662          flip: {
1663            enabled: this._config.flip
1664          },
1665          preventOverflow: {
1666            boundariesElement: this._config.boundary
1667          }
1668        }
1669      };
1670      return popperConfig;
1671    }; // Static
1672
1673
1674    Dropdown._jQueryInterface = function _jQueryInterface(config) {
1675      return this.each(function () {
1676        var data = $$$1(this).data(DATA_KEY);
1677
1678        var _config = typeof config === 'object' ? config : null;
1679
1680        if (!data) {
1681          data = new Dropdown(this, _config);
1682          $$$1(this).data(DATA_KEY, data);
1683        }
1684
1685        if (typeof config === 'string') {
1686          if (typeof data[config] === 'undefined') {
1687            throw new TypeError("No method named \"" + config + "\"");
1688          }
1689
1690          data[config]();
1691        }
1692      });
1693    };
1694
1695    Dropdown._clearMenus 

Large files files are truncated, but you can click here to view the full file