text: (function(global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('jquery'), require('popper.js')) :
          typeof define === 'function' && define.amd ? define(['jquery', 'popper.js'], factory) :
          (factory(global.jQuery, global.Popper));
  }(this, (function($, Popper$1) {
      'use strict';
  
      $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
      Popper$1 = Popper$1 && Popper$1.hasOwnProperty('default') ? Popper$1['default'] : Popper$1;
  
      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);
          }
      }
  
      function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
      }
  
      function _extends() {
          _extends = Object.assign || function(target) {
              for (var i = 1; i < arguments.length; i++) {
                  var source = arguments[i];
  
                  for (var key in source) {
                      if (Object.prototype.hasOwnProperty.call(source, key)) {
                          target[key] = source[key];
                      }
                  }
              }
  
              return target;
          };
  
          return _extends.apply(this, arguments);
      }
  
      function _inheritsLoose(subClass, superClass) {
          subClass.prototype = Object.create(superClass.prototype);
          subClass.prototype.constructor = subClass;
          subClass.__proto__ = superClass;
      }
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): util.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Util = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Private TransitionEnd Helpers
           * ------------------------------------------------------------------------
           */
          var transition = false;
          var MAX_UID = 1000000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
  
          function toType(obj) {
              return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
          }
  
          function getSpecialTransitionEndEvent() {
              return {
                  bindType: transition.end,
                  delegateType: transition.end,
                  handle: function handle(event) {
                      if ($$$1(event.target).is(this)) {
                          return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
                      }
  
                      return undefined; // eslint-disable-line no-undefined
                  }
              };
          }
  
          function transitionEndTest() {
              if (typeof window !== 'undefined' && window.QUnit) {
                  return false;
              }
  
              return {
                  end: 'transitionend'
              };
          }
  
          function transitionEndEmulator(duration) {
              var _this = this;
  
              var called = false;
              $$$1(this).one(Util.TRANSITION_END, function() {
                  called = true;
              });
              setTimeout(function() {
                  if (!called) {
                      Util.triggerTransitionEnd(_this);
                  }
              }, duration);
              return this;
          }
  
          function setTransitionEndSupport() {
              transition = transitionEndTest();
              $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
  
              if (Util.supportsTransitionEnd()) {
                  $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
              }
          }
          /**
           * --------------------------------------------------------------------------
           * Public Util Api
           * --------------------------------------------------------------------------
           */
  
  
          var Util = {
              TRANSITION_END: 'bsTransitionEnd',
              getUID: function getUID(prefix) {
                  do {
                      // eslint-disable-next-line no-bitwise
                      prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
                  } while (document.getElementById(prefix));
  
                  return prefix;
              },
              getSelectorFromElement: function getSelectorFromElement(element) {
                  var selector = element.getAttribute('data-target');
  
                  if (!selector || selector === '#') {
                      selector = element.getAttribute('href') || '';
                  }
  
                  try {
                      var $selector = $$$1(document).find(selector);
                      return $selector.length > 0 ? selector : null;
                  } catch (err) {
                      return null;
                  }
              },
              reflow: function reflow(element) {
                  return element.offsetHeight;
              },
              triggerTransitionEnd: function triggerTransitionEnd(element) {
                  $$$1(element).trigger(transition.end);
              },
              supportsTransitionEnd: function supportsTransitionEnd() {
                  return Boolean(transition);
              },
              isElement: function isElement(obj) {
                  return (obj[0] || obj).nodeType;
              },
              typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
                  for (var property in configTypes) {
                      if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
                          var expectedTypes = configTypes[property];
                          var value = config[property];
                          var valueType = value && Util.isElement(value) ? 'element' : toType(value);
  
                          if (!new RegExp(expectedTypes).test(valueType)) {
                              throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
                          }
                      }
                  }
              }
          };
          setTransitionEndSupport();
          return Util;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): alert.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Alert = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'alert';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.alert';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 150;
          var Selector = {
              DISMISS: '[data-dismiss="alert"]'
          };
          var Event = {
              CLOSE: "close" + EVENT_KEY,
              CLOSED: "closed" + EVENT_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              ALERT: 'alert',
              FADE: 'fade',
              SHOW: 'show'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Alert =
              /*#__PURE__*/
              function() {
                  function Alert(element) {
                      this._element = element;
                  } // Getters
  
  
                  var _proto = Alert.prototype;
  
                  // Public
                  _proto.close = function close(element) {
                      element = element || this._element;
  
                      var rootElement = this._getRootElement(element);
  
                      var customEvent = this._triggerCloseEvent(rootElement);
  
                      if (customEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      this._removeElement(rootElement);
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      this._element = null;
                  }; // Private
  
  
                  _proto._getRootElement = function _getRootElement(element) {
                      var selector = Util.getSelectorFromElement(element);
                      var parent = false;
  
                      if (selector) {
                          parent = $$$1(selector)[0];
                      }
  
                      if (!parent) {
                          parent = $$$1(element).closest("." + ClassName.ALERT)[0];
                      }
  
                      return parent;
                  };
  
                  _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
                      var closeEvent = $$$1.Event(Event.CLOSE);
                      $$$1(element).trigger(closeEvent);
                      return closeEvent;
                  };
  
                  _proto._removeElement = function _removeElement(element) {
                      var _this = this;
  
                      $$$1(element).removeClass(ClassName.SHOW);
  
                      if (!Util.supportsTransitionEnd() || !$$$1(element).hasClass(ClassName.FADE)) {
                          this._destroyElement(element);
  
                          return;
                      }
  
                      $$$1(element).one(Util.TRANSITION_END, function(event) {
                          return _this._destroyElement(element, event);
                      }).emulateTransitionEnd(TRANSITION_DURATION);
                  };
  
                  _proto._destroyElement = function _destroyElement(element) {
                      $$$1(element).detach().trigger(Event.CLOSED).remove();
                  }; // Static
  
  
                  Alert._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Alert(this);
                              $element.data(DATA_KEY, data);
                          }
  
                          if (config === 'close') {
                              data[config](this);
                          }
                      });
                  };
  
                  Alert._handleDismiss = function _handleDismiss(alertInstance) {
                      return function(event) {
                          if (event) {
                              event.preventDefault();
                          }
  
                          alertInstance.close(this);
                      };
                  };
  
                  _createClass(Alert, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }]);
  
                  return Alert;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Alert._jQueryInterface;
          $$$1.fn[NAME].Constructor = Alert;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Alert._jQueryInterface;
          };
  
          return Alert;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): button.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Button = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'button';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.button';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var ClassName = {
              ACTIVE: 'active',
              BUTTON: 'btn',
              FOCUS: 'focus'
          };
          var Selector = {
              DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
              DATA_TOGGLE: '[data-toggle="buttons"]',
              INPUT: 'input',
              ACTIVE: '.active',
              BUTTON: '.btn'
          };
          var Event = {
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
              FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Button =
              /*#__PURE__*/
              function() {
                  function Button(element) {
                      this._element = element;
                  } // Getters
  
  
                  var _proto = Button.prototype;
  
                  // Public
                  _proto.toggle = function toggle() {
                      var triggerChangeEvent = true;
                      var addAriaPressed = true;
                      var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
  
                      if (rootElement) {
                          var input = $$$1(this._element).find(Selector.INPUT)[0];
  
                          if (input) {
                              if (input.type === 'radio') {
                                  if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
                                      triggerChangeEvent = false;
                                  } else {
                                      var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
  
                                      if (activeElement) {
                                          $$$1(activeElement).removeClass(ClassName.ACTIVE);
                                      }
                                  }
                              }
  
                              if (triggerChangeEvent) {
                                  if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
                                      return;
                                  }
  
                                  input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
                                  $$$1(input).trigger('change');
                              }
  
                              input.focus();
                              addAriaPressed = false;
                          }
                      }
  
                      if (addAriaPressed) {
                          this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
                      }
  
                      if (triggerChangeEvent) {
                          $$$1(this._element).toggleClass(ClassName.ACTIVE);
                      }
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      this._element = null;
                  }; // Static
  
  
                  Button._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          if (!data) {
                              data = new Button(this);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (config === 'toggle') {
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(Button, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }]);
  
                  return Button;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function(event) {
              event.preventDefault();
              var button = event.target;
  
              if (!$$$1(button).hasClass(ClassName.BUTTON)) {
                  button = $$$1(button).closest(Selector.BUTTON);
              }
  
              Button._jQueryInterface.call($$$1(button), 'toggle');
          }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function(event) {
              var button = $$$1(event.target).closest(Selector.BUTTON)[0];
              $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Button._jQueryInterface;
          $$$1.fn[NAME].Constructor = Button;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Button._jQueryInterface;
          };
  
          return Button;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0-beta): carousel.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Carousel = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'carousel';
          var VERSION = '4.0.0-beta';
          var DATA_KEY = 'bs.carousel';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 600;
          var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
  
          var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
  
          var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
  
          var Default = {
              interval: 5000,
              keyboard: true,
              slide: false,
              pause: 'hover',
              wrap: true
          };
          var DefaultType = {
              interval: '(number|boolean)',
              keyboard: 'boolean',
              slide: '(boolean|string)',
              pause: '(string|boolean)',
              wrap: 'boolean'
          };
          var Direction = {
              NEXT: 'next',
              PREV: 'prev',
              LEFT: 'left',
              RIGHT: 'right'
          };
          var Event = {
              SLIDE: "slide" + EVENT_KEY,
              SLID: "slid" + EVENT_KEY,
              KEYDOWN: "keydown" + EVENT_KEY,
              MOUSEENTER: "mouseenter" + EVENT_KEY,
              MOUSELEAVE: "mouseleave" + EVENT_KEY,
              TOUCHEND: "touchend" + EVENT_KEY,
              LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              CAROUSEL: 'carousel',
              ACTIVE: 'active',
              SLIDE: 'slide',
              RIGHT: 'carousel-item-right',
              LEFT: 'carousel-item-left',
              NEXT: 'carousel-item-next',
              PREV: 'carousel-item-prev',
              ITEM: 'carousel-item'
          };
          var Selector = {
              ACTIVE: '.active',
              ACTIVE_ITEM: '.active.carousel-item',
              ITEM: '.carousel-item',
              NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
              INDICATORS: '.carousel-indicators',
              DATA_SLIDE: '[data-slide], [data-slide-to]',
              DATA_RIDE: '[data-ride="carousel"]'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Carousel =
              /*#__PURE__*/
              function() {
                  function Carousel(element, config) {
                      this._items = null;
                      this._interval = null;
                      this._activeElement = null;
                      this._isPaused = false;
                      this._isSliding = false;
                      this.touchTimeout = null;
                      this._config = this._getConfig(config);
                      this._element = $$$1(element)[0];
                      this._indicatorsElement = $$$1(this._element).find(Selector.INDICATORS)[0];
  
                      this._addEventListeners();
                  } // getters
  
  
                  var _proto = Carousel.prototype;
  
                  // public
                  _proto.next = function next() {
                      if (!this._isSliding) {
                          this._slide(Direction.NEXT);
                      }
                  };
  
                  _proto.nextWhenVisible = function nextWhenVisible() {
                      // Don't call next when the page isn't visible
                      if (!document.hidden) {
                          this.next();
                      }
                  };
  
                  _proto.prev = function prev() {
                      if (!this._isSliding) {
                          this._slide(Direction.PREV);
                      }
                  };
  
                  _proto.pause = function pause(event) {
                      if (!event) {
                          this._isPaused = true;
                      }
  
                      if ($$$1(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) {
                          Util.triggerTransitionEnd(this._element);
                          this.cycle(true);
                      }
  
                      clearInterval(this._interval);
                      this._interval = null;
                  };
  
                  _proto.cycle = function cycle(event) {
                      if (!event) {
                          this._isPaused = false;
                      }
  
                      if (this._interval) {
                          clearInterval(this._interval);
                          this._interval = null;
                      }
  
                      if (this._config.interval && !this._isPaused) {
                          this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
                      }
                  };
  
                  _proto.to = function to(index) {
                      var _this = this;
  
                      this._activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
  
                      var activeIndex = this._getItemIndex(this._activeElement);
  
                      if (index > this._items.length - 1 || index < 0) {
                          return;
                      }
  
                      if (this._isSliding) {
                          $$$1(this._element).one(Event.SLID, function() {
                              return _this.to(index);
                          });
                          return;
                      }
  
                      if (activeIndex === index) {
                          this.pause();
                          this.cycle();
                          return;
                      }
  
                      var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
  
                      this._slide(direction, this._items[index]);
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1(this._element).off(EVENT_KEY);
                      $$$1.removeData(this._element, DATA_KEY);
                      this._items = null;
                      this._config = null;
                      this._element = null;
                      this._interval = null;
                      this._isPaused = null;
                      this._isSliding = null;
                      this._activeElement = null;
                      this._indicatorsElement = null;
                  }; // private
  
  
                  _proto._getConfig = function _getConfig(config) {
                      config = $$$1.extend({}, Default, config);
                      Util.typeCheckConfig(NAME, config, DefaultType);
                      return config;
                  };
  
                  _proto._addEventListeners = function _addEventListeners() {
                      var _this2 = this;
  
                      if (this._config.keyboard) {
                          $$$1(this._element).on(Event.KEYDOWN, function(event) {
                              return _this2._keydown(event);
                          });
                      }
  
                      if (this._config.pause === 'hover') {
                          $$$1(this._element).on(Event.MOUSEENTER, function(event) {
                              return _this2.pause(event);
                          }).on(Event.MOUSELEAVE, function(event) {
                              return _this2.cycle(event);
                          });
  
                          if ('ontouchstart' in document.documentElement) {
                              // if it's a touch-enabled device, mouseenter/leave are fired as
                              // part of the mouse compatibility events on first tap - the carousel
                              // would stop cycling until user tapped out of it;
                              // here, we listen for touchend, explicitly pause the carousel
                              // (as if it's the second time we tap on it, mouseenter compat event
                              // is NOT fired) and after a timeout (to allow for mouse compatibility
                              // events to fire) we explicitly restart cycling
                              $$$1(this._element).on(Event.TOUCHEND, function() {
                                  _this2.pause();
  
                                  if (_this2.touchTimeout) {
                                      clearTimeout(_this2.touchTimeout);
                                  }
  
                                  _this2.touchTimeout = setTimeout(function(event) {
                                      return _this2.cycle(event);
                                  }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
                              });
                          }
                      }
                  };
  
                  _proto._keydown = function _keydown(event) {
                      if (/input|textarea/i.test(event.target.tagName)) {
                          return;
                      }
  
                      switch (event.which) {
                          case ARROW_LEFT_KEYCODE:
                              event.preventDefault();
                              this.prev();
                              break;
  
                          case ARROW_RIGHT_KEYCODE:
                              event.preventDefault();
                              this.next();
                              break;
  
                          default:
                              return;
                      }
                  };
  
                  _proto._getItemIndex = function _getItemIndex(element) {
                      this._items = $$$1.makeArray($$$1(element).parent().find(Selector.ITEM));
                      return this._items.indexOf(element);
                  };
  
                  _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
                      var isNextDirection = direction === Direction.NEXT;
                      var isPrevDirection = direction === Direction.PREV;
  
                      var activeIndex = this._getItemIndex(activeElement);
  
                      var lastItemIndex = this._items.length - 1;
                      var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
  
                      if (isGoingToWrap && !this._config.wrap) {
                          return activeElement;
                      }
  
                      var delta = direction === Direction.PREV ? -1 : 1;
                      var itemIndex = (activeIndex + delta) % this._items.length;
                      return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
                  };
  
                  _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
                      var targetIndex = this._getItemIndex(relatedTarget);
  
                      var fromIndex = this._getItemIndex($$$1(this._element).find(Selector.ACTIVE_ITEM)[0]);
  
                      var slideEvent = $$$1.Event(Event.SLIDE, {
                          relatedTarget: relatedTarget,
                          direction: eventDirectionName,
                          from: fromIndex,
                          to: targetIndex
                      });
                      $$$1(this._element).trigger(slideEvent);
                      return slideEvent;
                  };
  
                  _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
                      if (this._indicatorsElement) {
                          $$$1(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
  
                          var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
  
                          if (nextIndicator) {
                              $$$1(nextIndicator).addClass(ClassName.ACTIVE);
                          }
                      }
                  };
  
                  _proto._slide = function _slide(direction, element) {
                      var _this3 = this;
  
                      var activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
  
                      var activeElementIndex = this._getItemIndex(activeElement);
  
                      var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
  
                      var nextElementIndex = this._getItemIndex(nextElement);
  
                      var isCycling = Boolean(this._interval);
                      var directionalClassName;
                      var orderClassName;
                      var eventDirectionName;
  
                      if (direction === Direction.NEXT) {
                          directionalClassName = ClassName.LEFT;
                          orderClassName = ClassName.NEXT;
                          eventDirectionName = Direction.LEFT;
                      } else {
                          directionalClassName = ClassName.RIGHT;
                          orderClassName = ClassName.PREV;
                          eventDirectionName = Direction.RIGHT;
                      }
  
                      if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
                          this._isSliding = false;
                          return;
                      }
  
                      var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
  
                      if (slideEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      if (!activeElement || !nextElement) {
                          // some weirdness is happening, so we bail
                          return;
                      }
  
                      this._isSliding = true;
  
                      if (isCycling) {
                          this.pause();
                      }
  
                      this._setActiveIndicatorElement(nextElement);
  
                      var slidEvent = $$$1.Event(Event.SLID, {
                          relatedTarget: nextElement,
                          direction: eventDirectionName,
                          from: activeElementIndex,
                          to: nextElementIndex
                      });
  
                      if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.SLIDE)) {
                          $$$1(nextElement).addClass(orderClassName);
                          Util.reflow(nextElement);
                          $$$1(activeElement).addClass(directionalClassName);
                          $$$1(nextElement).addClass(directionalClassName);
                          $$$1(activeElement).one(Util.TRANSITION_END, function() {
                              $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
                              $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
                              _this3._isSliding = false;
                              setTimeout(function() {
                                  return $$$1(_this3._element).trigger(slidEvent);
                              }, 0);
                          }).emulateTransitionEnd(TRANSITION_DURATION);
                      } else {
                          $$$1(activeElement).removeClass(ClassName.ACTIVE);
                          $$$1(nextElement).addClass(ClassName.ACTIVE);
                          this._isSliding = false;
                          $$$1(this._element).trigger(slidEvent);
                      }
  
                      if (isCycling) {
                          this.cycle();
                      }
                  }; // static
  
  
                  Carousel._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = $$$1.extend({}, Default, $$$1(this).data());
  
                          if (typeof config === 'object') {
                              $$$1.extend(_config, config);
                          }
  
                          var action = typeof config === 'string' ? config : _config.slide;
  
                          if (!data) {
                              data = new Carousel(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'number') {
                              data.to(config);
                          } else if (typeof action === 'string') {
                              if (data[action] === undefined) {
                                  throw new Error("No method named \"" + action + "\"");
                              }
  
                              data[action]();
                          } else if (_config.interval) {
                              data.pause();
                              data.cycle();
                          }
                      });
                  };
  
                  Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
                      var selector = Util.getSelectorFromElement(this);
  
                      if (!selector) {
                          return;
                      }
  
                      var target = $$$1(selector)[0];
  
                      if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
                          return;
                      }
  
                      var config = $$$1.extend({}, $$$1(target).data(), $$$1(this).data());
                      var slideIndex = this.getAttribute('data-slide-to');
  
                      if (slideIndex) {
                          config.interval = false;
                      }
  
                      Carousel._jQueryInterface.call($$$1(target), config);
  
                      if (slideIndex) {
                          $$$1(target).data(DATA_KEY).to(slideIndex);
                      }
  
                      event.preventDefault();
                  };
  
                  _createClass(Carousel, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }]);
  
                  return Carousel;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
          $$$1(window).on(Event.LOAD_DATA_API, function() {
              $$$1(Selector.DATA_RIDE).each(function() {
                  var $carousel = $$$1(this);
  
                  Carousel._jQueryInterface.call($carousel, $carousel.data());
              });
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Carousel._jQueryInterface;
          $$$1.fn[NAME].Constructor = Carousel;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Carousel._jQueryInterface;
          };
  
          return Carousel;
      }(jQuery);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): collapse.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Collapse = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'collapse';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.collapse';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 600;
          var Default = {
              toggle: true,
              parent: ''
          };
          var DefaultType = {
              toggle: 'boolean',
              parent: '(string|element)'
          };
          var Event = {
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              SHOW: 'show',
              COLLAPSE: 'collapse',
              COLLAPSING: 'collapsing',
              COLLAPSED: 'collapsed'
          };
          var Dimension = {
              WIDTH: 'width',
              HEIGHT: 'height'
          };
          var Selector = {
              ACTIVES: '.show, .collapsing',
              DATA_TOGGLE: '[data-toggle="collapse"]'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Collapse =
              /*#__PURE__*/
              function() {
                  function Collapse(element, config) {
                      this._isTransitioning = false;
                      this._element = element;
                      this._config = this._getConfig(config);
                      this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
                      var tabToggles = $$$1(Selector.DATA_TOGGLE);
  
                      for (var i = 0; i < tabToggles.length; i++) {
                          var elem = tabToggles[i];
                          var selector = Util.getSelectorFromElement(elem);
  
                          if (selector !== null && $$$1(selector).filter(element).length > 0) {
                              this._selector = selector;
  
                              this._triggerArray.push(elem);
                          }
                      }
  
                      this._parent = this._config.parent ? this._getParent() : null;
  
                      if (!this._config.parent) {
                          this._addAriaAndCollapsedClass(this._element, this._triggerArray);
                      }
  
                      if (this._config.toggle) {
                          this.toggle();
                      }
                  } // Getters
  
  
                  var _proto = Collapse.prototype;
  
                  // Public
                  _proto.toggle = function toggle() {
                      if ($$$1(this._element).hasClass(ClassName.SHOW)) {
                          this.hide();
                      } else {
                          this.show();
                      }
                  };
  
                  _proto.show = function show() {
                      var _this = this;
  
                      if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
                          return;
                      }
  
                      var actives;
                      var activesData;
  
                      if (this._parent) {
                          actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
  
                          if (actives.length === 0) {
                              actives = null;
                          }
                      }
  
                      if (actives) {
                          activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
  
                          if (activesData && activesData._isTransitioning) {
                              return;
                          }
                      }
  
                      var startEvent = $$$1.Event(Event.SHOW);
                      $$$1(this._element).trigger(startEvent);
  
                      if (startEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      if (actives) {
                          Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
  
                          if (!activesData) {
                              $$$1(actives).data(DATA_KEY, null);
                          }
                      }
  
                      var dimension = this._getDimension();
  
                      $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
                      this._element.style[dimension] = 0;
  
                      if (this._triggerArray.length > 0) {
                          $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
                      }
  
                      this.setTransitioning(true);
  
                      var complete = function complete() {
                          $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
                          _this._element.style[dimension] = '';
  
                          _this.setTransitioning(false);
  
                          $$$1(_this._element).trigger(Event.SHOWN);
                      };
  
                      if (!Util.supportsTransitionEnd()) {
                          complete();
                          return;
                      }
  
                      var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
                      var scrollSize = "scroll" + capitalizedDimension;
                      $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
                      this._element.style[dimension] = this._element[scrollSize] + "px";
                  };
  
                  _proto.hide = function hide() {
                      var _this2 = this;
  
                      if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
                          return;
                      }
  
                      var startEvent = $$$1.Event(Event.HIDE);
                      $$$1(this._element).trigger(startEvent);
  
                      if (startEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      var dimension = this._getDimension();
  
                      this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
                      Util.reflow(this._element);
                      $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
  
                      if (this._triggerArray.length > 0) {
                          for (var i = 0; i < this._triggerArray.length; i++) {
                              var trigger = this._triggerArray[i];
                              var selector = Util.getSelectorFromElement(trigger);
  
                              if (selector !== null) {
                                  var $elem = $$$1(selector);
  
                                  if (!$elem.hasClass(ClassName.SHOW)) {
                                      $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
                                  }
                              }
                          }
                      }
  
                      this.setTransitioning(true);
  
                      var complete = function complete() {
                          _this2.setTransitioning(false);
  
                          $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
                      };
  
                      this._element.style[dimension] = '';
  
                      if (!Util.supportsTransitionEnd()) {
                          complete();
                          return;
                      }
  
                      $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
                  };
  
                  _proto.setTransitioning = function setTransitioning(isTransitioning) {
                      this._isTransitioning = isTransitioning;
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      this._config = null;
                      this._parent = null;
                      this._element = null;
                      this._triggerArray = null;
                      this._isTransitioning = null;
                  }; // Private
  
  
                  _proto._getConfig = function _getConfig(config) {
                      config = _extends({}, Default, config);
                      config.toggle = Boolean(config.toggle); // Coerce string values
  
                      Util.typeCheckConfig(NAME, config, DefaultType);
                      return config;
                  };
  
                  _proto._getDimension = function _getDimension() {
                      var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
                      return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
                  };
  
                  _proto._getParent = function _getParent() {
                      var _this3 = this;
  
                      var parent = null;
  
                      if (Util.isElement(this._config.parent)) {
                          parent = this._config.parent; // It's a jQuery object
  
                          if (typeof this._config.parent.jquery !== 'undefined') {
                              parent = this._config.parent[0];
                          }
                      } else {
                          parent = $$$1(this._config.parent)[0];
                      }
  
                      var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
                      $$$1(parent).find(selector).each(function(i, element) {
                          _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
                      });
                      return parent;
                  };
  
                  _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
                      if (element) {
                          var isOpen = $$$1(element).hasClass(ClassName.SHOW);
  
                          if (triggerArray.length > 0) {
                              $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
                          }
                      }
                  }; // Static
  
  
                  Collapse._getTargetFromElement = function _getTargetFromElement(element) {
                      var selector = Util.getSelectorFromElement(element);
                      return selector ? $$$1(selector)[0] : null;
                  };
  
                  Collapse._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $this = $$$1(this);
                          var data = $this.data(DATA_KEY);
  
                          var _config = _extends({}, Default, $this.data(), typeof config === 'object' && config);
  
                          if (!data && _config.toggle && /show|hide/.test(config)) {
                              _config.toggle = false;
                          }
  
                          if (!data) {
                              data = new Collapse(this, _config);
                              $this.data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(Collapse, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }]);
  
                  return Collapse;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function(event) {
              // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
              if (event.currentTarget.tagName === 'A') {
                  event.preventDefault();
              }
  
              var $trigger = $$$1(this);
              var selector = Util.getSelectorFromElement(this);
              $$$1(selector).each(function() {
                  var $target = $$$1(this);
                  var data = $target.data(DATA_KEY);
                  var config = data ? 'toggle' : $trigger.data();
  
                  Collapse._jQueryInterface.call($target, config);
              });
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Collapse._jQueryInterface;
          $$$1.fn[NAME].Constructor = Collapse;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Collapse._jQueryInterface;
          };
  
          return Collapse;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): modal.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Modal = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'modal';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.modal';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 300;
          var BACKDROP_TRANSITION_DURATION = 150;
          var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
  
          var Default = {
              backdrop: true,
              keyboard: true,
              focus: true,
              show: true
          };
          var DefaultType = {
              backdrop: '(boolean|string)',
              keyboard: 'boolean',
              focus: 'boolean',
              show: 'boolean'
          };
          var Event = {
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              FOCUSIN: "focusin" + EVENT_KEY,
              RESIZE: "resize" + EVENT_KEY,
              CLICK_DISMISS: "click.dismiss" + EVENT_KEY,
              KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY,
              MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY,
              MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
              BACKDROP: 'modal-backdrop',
              OPEN: 'modal-open',
              FADE: 'fade',
              SHOW: 'show'
          };
          var Selector = {
              DIALOG: '.modal-dialog',
              DATA_TOGGLE: '[data-toggle="modal"]',
              DATA_DISMISS: '[data-dismiss="modal"]',
              FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
              STICKY_CONTENT: '.sticky-top',
              NAVBAR_TOGGLER: '.navbar-toggler'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Modal =
              /*#__PURE__*/
              function() {
                  function Modal(element, config) {
                      this._config = this._getConfig(config);
                      this._element = element;
                      this._dialog = $$$1(element).find(Selector.DIALOG)[0];
                      this._backdrop = null;
                      this._isShown = false;
                      this._isBodyOverflowing = false;
                      this._ignoreBackdropClick = false;
                      this._originalBodyPadding = 0;
                      this._scrollbarWidth = 0;
                  } // Getters
  
  
                  var _proto = Modal.prototype;
  
                  // Public
                  _proto.toggle = function toggle(relatedTarget) {
                      return this._isShown ? this.hide() : this.show(relatedTarget);
                  };
  
                  _proto.show = function show(relatedTarget) {
                      var _this = this;
  
                      if (this._isTransitioning || this._isShown) {
                          return;
                      }
  
                      if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
                          this._isTransitioning = true;
                      }
  
                      var showEvent = $$$1.Event(Event.SHOW, {
                          relatedTarget: relatedTarget
                      });
                      $$$1(this._element).trigger(showEvent);
  
                      if (this._isShown || showEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      this._isShown = true;
  
                      this._checkScrollbar();
  
                      this._setScrollbar();
  
                      this._adjustDialog();
  
                      $$$1(document.body).addClass(ClassName.OPEN);
  
                      this._setEscapeEvent();
  
                      this._setResizeEvent();
  
                      $$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function(event) {
                          return _this.hide(event);
                      });
                      $$$1(this._dialog).on(Event.MOUSEDOWN_DISMISS, function() {
                          $$$1(_this._element).one(Event.MOUSEUP_DISMISS, function(event) {
                              if ($$$1(event.target).is(_this._element)) {
                                  _this._ignoreBackdropClick = true;
                              }
                          });
                      });
  
                      this._showBackdrop(function() {
                          return _this._showElement(relatedTarget);
                      });
                  };
  
                  _proto.hide = function hide(event) {
                      var _this2 = this;
  
                      if (event) {
                          event.preventDefault();
                      }
  
                      if (this._isTransitioning || !this._isShown) {
                          return;
                      }
  
                      var hideEvent = $$$1.Event(Event.HIDE);
                      $$$1(this._element).trigger(hideEvent);
  
                      if (!this._isShown || hideEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      this._isShown = false;
                      var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
  
                      if (transition) {
                          this._isTransitioning = true;
                      }
  
                      this._setEscapeEvent();
  
                      this._setResizeEvent();
  
                      $$$1(document).off(Event.FOCUSIN);
                      $$$1(this._element).removeClass(ClassName.SHOW);
                      $$$1(this._element).off(Event.CLICK_DISMISS);
                      $$$1(this._dialog).off(Event.MOUSEDOWN_DISMISS);
  
                      if (transition) {
                          $$$1(this._element).one(Util.TRANSITION_END, function(event) {
                              return _this2._hideModal(event);
                          }).emulateTransitionEnd(TRANSITION_DURATION);
                      } else {
                          this._hideModal();
                      }
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      $$$1(window, document, this._element, this._backdrop).off(EVENT_KEY);
                      this._config = null;
                      this._element = null;
                      this._dialog = null;
                      this._backdrop = null;
                      this._isShown = null;
                      this._isBodyOverflowing = null;
                      this._ignoreBackdropClick = null;
                      this._scrollbarWidth = null;
                  };
  
                  _proto.handleUpdate = function handleUpdate() {
                      this._adjustDialog();
                  }; // Private
  
  
                  _proto._getConfig = function _getConfig(config) {
                      config = _extends({}, Default, config);
                      Util.typeCheckConfig(NAME, config, DefaultType);
                      return config;
                  };
  
                  _proto._showElement = function _showElement(relatedTarget) {
                      var _this3 = this;
  
                      var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
  
                      if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
                          // Don't move modal's DOM position
                          document.body.appendChild(this._element);
                      }
  
                      this._element.style.display = 'block';
  
                      this._element.removeAttribute('aria-hidden');
  
                      this._element.scrollTop = 0;
  
                      if (transition) {
                          Util.reflow(this._element);
                      }
  
                      $$$1(this._element).addClass(ClassName.SHOW);
  
                      if (this._config.focus) {
                          this._enforceFocus();
                      }
  
                      var shownEvent = $$$1.Event(Event.SHOWN, {
                          relatedTarget: relatedTarget
                      });
  
                      var transitionComplete = function transitionComplete() {
                          if (_this3._config.focus) {
                              _this3._element.focus();
                          }
  
                          _this3._isTransitioning = false;
                          $$$1(_this3._element).trigger(shownEvent);
                      };
  
                      if (transition) {
                          $$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(TRANSITION_DURATION);
                      } else {
                          transitionComplete();
                      }
                  };
  
                  _proto._enforceFocus = function _enforceFocus() {
                      var _this4 = this;
  
                      $$$1(document).off(Event.FOCUSIN) // Guard against infinite focus loop
                          .on(Event.FOCUSIN, function(event) {
                              if (document !== event.target && _this4._element !== event.target && $$$1(_this4._element).has(event.target).length === 0) {
                                  _this4._element.focus();
                              }
                          });
                  };
  
                  _proto._setEscapeEvent = function _setEscapeEvent() {
                      var _this5 = this;
  
                      if (this._isShown && this._config.keyboard) {
                          $$$1(this._element).on(Event.KEYDOWN_DISMISS, function(event) {
                              if (event.which === ESCAPE_KEYCODE) {
                                  event.preventDefault();
  
                                  _this5.hide();
                              }
                          });
                      } else if (!this._isShown) {
                          $$$1(this._element).off(Event.KEYDOWN_DISMISS);
                      }
                  };
  
                  _proto._setResizeEvent = function _setResizeEvent() {
                      var _this6 = this;
  
                      if (this._isShown) {
                          $$$1(window).on(Event.RESIZE, function(event) {
                              return _this6.handleUpdate(event);
                          });
                      } else {
                          $$$1(window).off(Event.RESIZE);
                      }
                  };
  
                  _proto._hideModal = function _hideModal() {
                      var _this7 = this;
  
                      this._element.style.display = 'none';
  
                      this._element.setAttribute('aria-hidden', true);
  
                      this._isTransitioning = false;
  
                      this._showBackdrop(function() {
                          $$$1(document.body).removeClass(ClassName.OPEN);
  
                          _this7._resetAdjustments();
  
                          _this7._resetScrollbar();
  
                          $$$1(_this7._element).trigger(Event.HIDDEN);
                      });
                  };
  
                  _proto._removeBackdrop = function _removeBackdrop() {
                      if (this._backdrop) {
                          $$$1(this._backdrop).remove();
                          this._backdrop = null;
                      }
                  };
  
                  _proto._showBackdrop = function _showBackdrop(callback) {
                      var _this8 = this;
  
                      var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
  
                      if (this._isShown && this._config.backdrop) {
                          var doAnimate = Util.supportsTransitionEnd() && animate;
                          this._backdrop = document.createElement('div');
                          this._backdrop.className = ClassName.BACKDROP;
  
                          if (animate) {
                              $$$1(this._backdrop).addClass(animate);
                          }
  
                          $$$1(this._backdrop).appendTo(document.body);
                          $$$1(this._element).on(Event.CLICK_DISMISS, function(event) {
                              if (_this8._ignoreBackdropClick) {
                                  _this8._ignoreBackdropClick = false;
                                  return;
                              }
  
                              if (event.target !== event.currentTarget) {
                                  return;
                              }
  
                              if (_this8._config.backdrop === 'static') {
                                  _this8._element.focus();
                              } else {
                                  _this8.hide();
                              }
                          });
  
                          if (doAnimate) {
                              Util.reflow(this._backdrop);
                          }
  
                          $$$1(this._backdrop).addClass(ClassName.SHOW);
  
                          if (!callback) {
                              return;
                          }
  
                          if (!doAnimate) {
                              callback();
                              return;
                          }
  
                          $$$1(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
                      } else if (!this._isShown && this._backdrop) {
                          $$$1(this._backdrop).removeClass(ClassName.SHOW);
  
                          var callbackRemove = function callbackRemove() {
                              _this8._removeBackdrop();
  
                              if (callback) {
                                  callback();
                              }
                          };
  
                          if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
                              $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
                          } else {
                              callbackRemove();
                          }
                      } else if (callback) {
                          callback();
                      }
                  }; // ----------------------------------------------------------------------
                  // the following methods are used to handle overflowing modals
                  // todo (fat): these should probably be refactored out of modal.js
                  // ----------------------------------------------------------------------
  
  
                  _proto._adjustDialog = function _adjustDialog() {
                      var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
  
                      if (!this._isBodyOverflowing && isModalOverflowing) {
                          this._element.style.paddingLeft = this._scrollbarWidth + "px";
                      }
  
                      if (this._isBodyOverflowing && !isModalOverflowing) {
                          this._element.style.paddingRight = this._scrollbarWidth + "px";
                      }
                  };
  
                  _proto._resetAdjustments = function _resetAdjustments() {
                      this._element.style.paddingLeft = '';
                      this._element.style.paddingRight = '';
                  };
  
                  _proto._checkScrollbar = function _checkScrollbar() {
                      var rect = document.body.getBoundingClientRect();
                      this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
                      this._scrollbarWidth = this._getScrollbarWidth();
                  };
  
                  _proto._setScrollbar = function _setScrollbar() {
                      var _this9 = this;
  
                      if (this._isBodyOverflowing) {
                          // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
                          //   while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
                          // Adjust fixed content padding
                          $$$1(Selector.FIXED_CONTENT).each(function(index, element) {
                              var actualPadding = $$$1(element)[0].style.paddingRight;
                              var calculatedPadding = $$$1(element).css('padding-right');
                              $$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
                          }); // Adjust sticky content margin
  
                          $$$1(Selector.STICKY_CONTENT).each(function(index, element) {
                              var actualMargin = $$$1(element)[0].style.marginRight;
                              var calculatedMargin = $$$1(element).css('margin-right');
                              $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
                          }); // Adjust navbar-toggler margin
  
                          $$$1(Selector.NAVBAR_TOGGLER).each(function(index, element) {
                              var actualMargin = $$$1(element)[0].style.marginRight;
                              var calculatedMargin = $$$1(element).css('margin-right');
                              $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) + _this9._scrollbarWidth + "px");
                          }); // Adjust body padding
  
                          var actualPadding = document.body.style.paddingRight;
                          var calculatedPadding = $$$1('body').css('padding-right');
                          $$$1('body').data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
                      }
                  };
  
                  _proto._resetScrollbar = function _resetScrollbar() {
                      // Restore fixed content padding
                      $$$1(Selector.FIXED_CONTENT).each(function(index, element) {
                          var padding = $$$1(element).data('padding-right');
  
                          if (typeof padding !== 'undefined') {
                              $$$1(element).css('padding-right', padding).removeData('padding-right');
                          }
                      }); // Restore sticky content and navbar-toggler margin
  
                      $$$1(Selector.STICKY_CONTENT + ", " + Selector.NAVBAR_TOGGLER).each(function(index, element) {
                          var margin = $$$1(element).data('margin-right');
  
                          if (typeof margin !== 'undefined') {
                              $$$1(element).css('margin-right', margin).removeData('margin-right');
                          }
                      }); // Restore body padding
  
                      var padding = $$$1('body').data('padding-right');
  
                      if (typeof padding !== 'undefined') {
                          $$$1('body').css('padding-right', padding).removeData('padding-right');
                      }
                  };
  
                  _proto._getScrollbarWidth = function _getScrollbarWidth() {
                      // thx d.walsh
                      var scrollDiv = document.createElement('div');
                      scrollDiv.className = ClassName.SCROLLBAR_MEASURER;
                      document.body.appendChild(scrollDiv);
                      var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
                      document.body.removeChild(scrollDiv);
                      return scrollbarWidth;
                  }; // Static
  
  
                  Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = _extends({}, Modal.Default, $$$1(this).data(), typeof config === 'object' && config);
  
                          if (!data) {
                              data = new Modal(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config](relatedTarget);
                          } else if (_config.show) {
                              data.show(relatedTarget);
                          }
                      });
                  };
  
                  _createClass(Modal, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }]);
  
                  return Modal;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function(event) {
              var _this10 = this;
  
              var target;
              var selector = Util.getSelectorFromElement(this);
  
              if (selector) {
                  target = $$$1(selector)[0];
              }
  
              var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _extends({}, $$$1(target).data(), $$$1(this).data());
  
              if (this.tagName === 'A' || this.tagName === 'AREA') {
                  event.preventDefault();
              }
  
              var $target = $$$1(target).one(Event.SHOW, function(showEvent) {
                  if (showEvent.isDefaultPrevented()) {
                      // Only register focus restorer if modal will actually get shown
                      return;
                  }
  
                  $target.one(Event.HIDDEN, function() {
                      if ($$$1(_this10).is(':visible')) {
                          _this10.focus();
                      }
                  });
              });
  
              Modal._jQueryInterface.call($$$1(target), config, this);
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Modal._jQueryInterface;
          $$$1.fn[NAME].Constructor = Modal;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Modal._jQueryInterface;
          };
  
          return Modal;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): tooltip.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Tooltip = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'tooltip';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.tooltip';
          var EVENT_KEY = "." + DATA_KEY;
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 150;
          var CLASS_PREFIX = 'bs-tooltip';
          var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
          var DefaultType = {
              animation: 'boolean',
              template: 'string',
              title: '(string|element|function)',
              trigger: 'string',
              delay: '(number|object)',
              html: 'boolean',
              selector: '(string|boolean)',
              placement: '(string|function)',
              offset: '(number|string)',
              container: '(string|element|boolean)',
              fallbackPlacement: '(string|array)',
              boundary: '(string|element)'
          };
          var AttachmentMap = {
              AUTO: 'auto',
              TOP: 'top',
              RIGHT: 'right',
              BOTTOM: 'bottom',
              LEFT: 'left'
          };
          var Default = {
              animation: true,
              template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
              trigger: 'hover focus',
              title: '',
              delay: 0,
              html: false,
              selector: false,
              placement: 'top',
              offset: 0,
              container: false,
              fallbackPlacement: 'flip',
              boundary: 'scrollParent'
          };
          var HoverState = {
              SHOW: 'show',
              OUT: 'out'
          };
          var Event = {
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              INSERTED: "inserted" + EVENT_KEY,
              CLICK: "click" + EVENT_KEY,
              FOCUSIN: "focusin" + EVENT_KEY,
              FOCUSOUT: "focusout" + EVENT_KEY,
              MOUSEENTER: "mouseenter" + EVENT_KEY,
              MOUSELEAVE: "mouseleave" + EVENT_KEY
          };
          var ClassName = {
              FADE: 'fade',
              SHOW: 'show'
          };
          var Selector = {
              TOOLTIP: '.tooltip',
              TOOLTIP_INNER: '.tooltip-inner',
              ARROW: '.arrow'
          };
          var Trigger = {
              HOVER: 'hover',
              FOCUS: 'focus',
              CLICK: 'click',
              MANUAL: 'manual'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Tooltip =
              /*#__PURE__*/
              function() {
                  function Tooltip(element, config) {
                      /**
                       * Check for Popper dependency
                       * Popper - https://popper.js.org
                       */
                      if (typeof Popper$1 === 'undefined') {
                          throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
                      } // private
  
  
                      this._isEnabled = true;
                      this._timeout = 0;
                      this._hoverState = '';
                      this._activeTrigger = {};
                      this._popper = null; // Protected
  
                      this.element = element;
                      this.config = this._getConfig(config);
                      this.tip = null;
  
                      this._setListeners();
                  } // Getters
  
  
                  var _proto = Tooltip.prototype;
  
                  // Public
                  _proto.enable = function enable() {
                      this._isEnabled = true;
                  };
  
                  _proto.disable = function disable() {
                      this._isEnabled = false;
                  };
  
                  _proto.toggleEnabled = function toggleEnabled() {
                      this._isEnabled = !this._isEnabled;
                  };
  
                  _proto.toggle = function toggle(event) {
                      if (!this._isEnabled) {
                          return;
                      }
  
                      if (event) {
                          var dataKey = this.constructor.DATA_KEY;
                          var context = $$$1(event.currentTarget).data(dataKey);
  
                          if (!context) {
                              context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                              $$$1(event.currentTarget).data(dataKey, context);
                          }
  
                          context._activeTrigger.click = !context._activeTrigger.click;
  
                          if (context._isWithActiveTrigger()) {
                              context._enter(null, context);
                          } else {
                              context._leave(null, context);
                          }
                      } else {
                          if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
                              this._leave(null, this);
  
                              return;
                          }
  
                          this._enter(null, this);
                      }
                  };
  
                  _proto.dispose = function dispose() {
                      clearTimeout(this._timeout);
                      $$$1.removeData(this.element, this.constructor.DATA_KEY);
                      $$$1(this.element).off(this.constructor.EVENT_KEY);
                      $$$1(this.element).closest('.modal').off('hide.bs.modal');
  
                      if (this.tip) {
                          $$$1(this.tip).remove();
                      }
  
                      this._isEnabled = null;
                      this._timeout = null;
                      this._hoverState = null;
                      this._activeTrigger = null;
  
                      if (this._popper !== null) {
                          this._popper.destroy();
                      }
  
                      this._popper = null;
                      this.element = null;
                      this.config = null;
                      this.tip = null;
                  };
  
                  _proto.show = function show() {
                      var _this = this;
  
                      if ($$$1(this.element).css('display') === 'none') {
                          throw new Error('Please use show on visible elements');
                      }
  
                      var showEvent = $$$1.Event(this.constructor.Event.SHOW);
  
                      if (this.isWithContent() && this._isEnabled) {
                          $$$1(this.element).trigger(showEvent);
                          var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
  
                          if (showEvent.isDefaultPrevented() || !isInTheDom) {
                              return;
                          }
  
                          var tip = this.getTipElement();
                          var tipId = Util.getUID(this.constructor.NAME);
                          tip.setAttribute('id', tipId);
                          this.element.setAttribute('aria-describedby', tipId);
                          this.setContent();
  
                          if (this.config.animation) {
                              $$$1(tip).addClass(ClassName.FADE);
                          }
  
                          var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
  
                          var attachment = this._getAttachment(placement);
  
                          this.addAttachmentClass(attachment);
                          var container = this.config.container === false ? document.body : $$$1(this.config.container);
                          $$$1(tip).data(this.constructor.DATA_KEY, this);
  
                          if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
                              $$$1(tip).appendTo(container);
                          }
  
                          $$$1(this.element).trigger(this.constructor.Event.INSERTED);
                          this._popper = new Popper$1(this.element, tip, {
                              placement: attachment,
                              modifiers: {
                                  offset: {
                                      offset: this.config.offset
                                  },
                                  flip: {
                                      behavior: this.config.fallbackPlacement
                                  },
                                  arrow: {
                                      element: Selector.ARROW
                                  },
                                  preventOverflow: {
                                      boundariesElement: this.config.boundary
                                  }
                              },
                              onCreate: function onCreate(data) {
                                  if (data.originalPlacement !== data.placement) {
                                      _this._handlePopperPlacementChange(data);
                                  }
                              },
                              onUpdate: function onUpdate(data) {
                                  _this._handlePopperPlacementChange(data);
                              }
                          });
                          $$$1(tip).addClass(ClassName.SHOW); // If this is a touch-enabled device we add extra
                          // empty mouseover listeners to the body's immediate children;
                          // only needed because of broken event delegation on iOS
                          // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
  
                          if ('ontouchstart' in document.documentElement) {
                              $$$1('body').children().on('mouseover', null, $$$1.noop);
                          }
  
                          var complete = function complete() {
                              if (_this.config.animation) {
                                  _this._fixTransition();
                              }
  
                              var prevHoverState = _this._hoverState;
                              _this._hoverState = null;
                              $$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
  
                              if (prevHoverState === HoverState.OUT) {
                                  _this._leave(null, _this);
                              }
                          };
  
                          if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
                              $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION);
                          } else {
                              complete();
                          }
                      }
                  };
  
                  _proto.hide = function hide(callback) {
                      var _this2 = this;
  
                      var tip = this.getTipElement();
                      var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
  
                      var complete = function complete() {
                          if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
                              tip.parentNode.removeChild(tip);
                          }
  
                          _this2._cleanTipClass();
  
                          _this2.element.removeAttribute('aria-describedby');
  
                          $$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
  
                          if (_this2._popper !== null) {
                              _this2._popper.destroy();
                          }
  
                          if (callback) {
                              callback();
                          }
                      };
  
                      $$$1(this.element).trigger(hideEvent);
  
                      if (hideEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      $$$1(tip).removeClass(ClassName.SHOW); // If this is a touch-enabled device we remove the extra
                      // empty mouseover listeners we added for iOS support
  
                      if ('ontouchstart' in document.documentElement) {
                          $$$1('body').children().off('mouseover', null, $$$1.noop);
                      }
  
                      this._activeTrigger[Trigger.CLICK] = false;
                      this._activeTrigger[Trigger.FOCUS] = false;
                      this._activeTrigger[Trigger.HOVER] = false;
  
                      if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
                          $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
                      } else {
                          complete();
                      }
  
                      this._hoverState = '';
                  };
  
                  _proto.update = function update() {
                      if (this._popper !== null) {
                          this._popper.scheduleUpdate();
                      }
                  }; // Protected
  
  
                  _proto.isWithContent = function isWithContent() {
                      return Boolean(this.getTitle());
                  };
  
                  _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                      $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
                  };
  
                  _proto.getTipElement = function getTipElement() {
                      this.tip = this.tip || $$$1(this.config.template)[0];
                      return this.tip;
                  };
  
                  _proto.setContent = function setContent() {
                      var $tip = $$$1(this.getTipElement());
                      this.setElementContent($tip.find(Selector.TOOLTIP_INNER), this.getTitle());
                      $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
                  };
  
                  _proto.setElementContent = function setElementContent($element, content) {
                      var html = this.config.html;
  
                      if (typeof content === 'object' && (content.nodeType || content.jquery)) {
                          // Content is a DOM node or a jQuery
                          if (html) {
                              if (!$$$1(content).parent().is($element)) {
                                  $element.empty().append(content);
                              }
                          } else {
                              $element.text($$$1(content).text());
                          }
                      } else {
                          $element[html ? 'html' : 'text'](content);
                      }
                  };
  
                  _proto.getTitle = function getTitle() {
                      var title = this.element.getAttribute('data-original-title');
  
                      if (!title) {
                          title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
                      }
  
                      return title;
                  }; // Private
  
  
                  _proto._getAttachment = function _getAttachment(placement) {
                      return AttachmentMap[placement.toUpperCase()];
                  };
  
                  _proto._setListeners = function _setListeners() {
                      var _this3 = this;
  
                      var triggers = this.config.trigger.split(' ');
                      triggers.forEach(function(trigger) {
                          if (trigger === 'click') {
                              $$$1(_this3.element).on(_this3.constructor.Event.CLICK, _this3.config.selector, function(event) {
                                  return _this3.toggle(event);
                              });
                          } else if (trigger !== Trigger.MANUAL) {
                              var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
                              var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
                              $$$1(_this3.element).on(eventIn, _this3.config.selector, function(event) {
                                  return _this3._enter(event);
                              }).on(eventOut, _this3.config.selector, function(event) {
                                  return _this3._leave(event);
                              });
                          }
  
                          $$$1(_this3.element).closest('.modal').on('hide.bs.modal', function() {
                              return _this3.hide();
                          });
                      });
  
                      if (this.config.selector) {
                          this.config = _extends({}, this.config, {
                              trigger: 'manual',
                              selector: ''
                          });
                      } else {
                          this._fixTitle();
                      }
                  };
  
                  _proto._fixTitle = function _fixTitle() {
                      var titleType = typeof this.element.getAttribute('data-original-title');
  
                      if (this.element.getAttribute('title') || titleType !== 'string') {
                          this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
                          this.element.setAttribute('title', '');
                      }
                  };
  
                  _proto._enter = function _enter(event, context) {
                      var dataKey = this.constructor.DATA_KEY;
                      context = context || $$$1(event.currentTarget).data(dataKey);
  
                      if (!context) {
                          context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                          $$$1(event.currentTarget).data(dataKey, context);
                      }
  
                      if (event) {
                          context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
                      }
  
                      if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
                          context._hoverState = HoverState.SHOW;
                          return;
                      }
  
                      clearTimeout(context._timeout);
                      context._hoverState = HoverState.SHOW;
  
                      if (!context.config.delay || !context.config.delay.show) {
                          context.show();
                          return;
                      }
  
                      context._timeout = setTimeout(function() {
                          if (context._hoverState === HoverState.SHOW) {
                              context.show();
                          }
                      }, context.config.delay.show);
                  };
  
                  _proto._leave = function _leave(event, context) {
                      var dataKey = this.constructor.DATA_KEY;
                      context = context || $$$1(event.currentTarget).data(dataKey);
  
                      if (!context) {
                          context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                          $$$1(event.currentTarget).data(dataKey, context);
                      }
  
                      if (event) {
                          context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
                      }
  
                      if (context._isWithActiveTrigger()) {
                          return;
                      }
  
                      clearTimeout(context._timeout);
                      context._hoverState = HoverState.OUT;
  
                      if (!context.config.delay || !context.config.delay.hide) {
                          context.hide();
                          return;
                      }
  
                      context._timeout = setTimeout(function() {
                          if (context._hoverState === HoverState.OUT) {
                              context.hide();
                          }
                      }, context.config.delay.hide);
                  };
  
                  _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
                      for (var trigger in this._activeTrigger) {
                          if (this._activeTrigger[trigger]) {
                              return true;
                          }
                      }
  
                      return false;
                  };
  
                  _proto._getConfig = function _getConfig(config) {
                      config = _extends({}, this.constructor.Default, $$$1(this.element).data(), config);
  
                      if (typeof config.delay === 'number') {
                          config.delay = {
                              show: config.delay,
                              hide: config.delay
                          };
                      }
  
                      if (typeof config.title === 'number') {
                          config.title = config.title.toString();
                      }
  
                      if (typeof config.content === 'number') {
                          config.content = config.content.toString();
                      }
  
                      Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
                      return config;
                  };
  
                  _proto._getDelegateConfig = function _getDelegateConfig() {
                      var config = {};
  
                      if (this.config) {
                          for (var key in this.config) {
                              if (this.constructor.Default[key] !== this.config[key]) {
                                  config[key] = this.config[key];
                              }
                          }
                      }
  
                      return config;
                  };
  
                  _proto._cleanTipClass = function _cleanTipClass() {
                      var $tip = $$$1(this.getTipElement());
                      var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
  
                      if (tabClass !== null && tabClass.length > 0) {
                          $tip.removeClass(tabClass.join(''));
                      }
                  };
  
                  _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(data) {
                      this._cleanTipClass();
  
                      this.addAttachmentClass(this._getAttachment(data.placement));
                  };
  
                  _proto._fixTransition = function _fixTransition() {
                      var tip = this.getTipElement();
                      var initConfigAnimation = this.config.animation;
  
                      if (tip.getAttribute('x-placement') !== null) {
                          return;
                      }
  
                      $$$1(tip).removeClass(ClassName.FADE);
                      this.config.animation = false;
                      this.hide();
                      this.show();
                      this.config.animation = initConfigAnimation;
                  }; // Static
  
  
                  Tooltip._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = typeof config === 'object' && config;
  
                          if (!data && /dispose|hide/.test(config)) {
                              return;
                          }
  
                          if (!data) {
                              data = new Tooltip(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(Tooltip, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }, {
                      key: "NAME",
                      get: function get() {
                          return NAME;
                      }
                  }, {
                      key: "DATA_KEY",
                      get: function get() {
                          return DATA_KEY;
                      }
                  }, {
                      key: "Event",
                      get: function get() {
                          return Event;
                      }
                  }, {
                      key: "EVENT_KEY",
                      get: function get() {
                          return EVENT_KEY;
                      }
                  }, {
                      key: "DefaultType",
                      get: function get() {
                          return DefaultType;
                      }
                  }]);
  
                  return Tooltip;
              }();
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[NAME] = Tooltip._jQueryInterface;
          $$$1.fn[NAME].Constructor = Tooltip;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Tooltip._jQueryInterface;
          };
  
          return Tooltip;
      }($, Popper$1);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): popover.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Popover = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'popover';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.popover';
          var EVENT_KEY = "." + DATA_KEY;
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var CLASS_PREFIX = 'bs-popover';
          var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
  
          var Default = _extends({}, Tooltip.Default, {
              placement: 'right',
              trigger: 'click',
              content: '',
              template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
          });
  
          var DefaultType = _extends({}, Tooltip.DefaultType, {
              content: '(string|element|function)'
          });
  
          var ClassName = {
              FADE: 'fade',
              SHOW: 'show'
          };
          var Selector = {
              TITLE: '.popover-header',
              CONTENT: '.popover-body'
          };
          var Event = {
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              INSERTED: "inserted" + EVENT_KEY,
              CLICK: "click" + EVENT_KEY,
              FOCUSIN: "focusin" + EVENT_KEY,
              FOCUSOUT: "focusout" + EVENT_KEY,
              MOUSEENTER: "mouseenter" + EVENT_KEY,
              MOUSELEAVE: "mouseleave" + EVENT_KEY
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Popover =
              /*#__PURE__*/
              function(_Tooltip) {
                  _inheritsLoose(Popover, _Tooltip);
  
                  function Popover() {
                      return _Tooltip.apply(this, arguments) || this;
                  }
  
                  var _proto = Popover.prototype;
  
                  // Overrides
                  _proto.isWithContent = function isWithContent() {
                      return this.getTitle() || this._getContent();
                  };
  
                  _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                      $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
                  };
  
                  _proto.getTipElement = function getTipElement() {
                      this.tip = this.tip || $$$1(this.config.template)[0];
                      return this.tip;
                  };
  
                  _proto.setContent = function setContent() {
                      var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
  
                      this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
  
                      var content = this._getContent();
  
                      if (typeof content === 'function') {
                          content = content.call(this.element);
                      }
  
                      this.setElementContent($tip.find(Selector.CONTENT), content);
                      $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
                  }; // Private
  
  
                  _proto._getContent = function _getContent() {
                      return this.element.getAttribute('data-content') || this.config.content;
                  };
  
                  _proto._cleanTipClass = function _cleanTipClass() {
                      var $tip = $$$1(this.getTipElement());
                      var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
  
                      if (tabClass !== null && tabClass.length > 0) {
                          $tip.removeClass(tabClass.join(''));
                      }
                  }; // Static
  
  
                  Popover._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = typeof config === 'object' ? config : null;
  
                          if (!data && /destroy|hide/.test(config)) {
                              return;
                          }
  
                          if (!data) {
                              data = new Popover(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(Popover, null, [{
                      key: "VERSION",
                      // Getters
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }, {
                      key: "NAME",
                      get: function get() {
                          return NAME;
                      }
                  }, {
                      key: "DATA_KEY",
                      get: function get() {
                          return DATA_KEY;
                      }
                  }, {
                      key: "Event",
                      get: function get() {
                          return Event;
                      }
                  }, {
                      key: "EVENT_KEY",
                      get: function get() {
                          return EVENT_KEY;
                      }
                  }, {
                      key: "DefaultType",
                      get: function get() {
                          return DefaultType;
                      }
                  }]);
  
                  return Popover;
              }(Tooltip);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[NAME] = Popover._jQueryInterface;
          $$$1.fn[NAME].Constructor = Popover;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Popover._jQueryInterface;
          };
  
          return Popover;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): scrollspy.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var ScrollSpy = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'scrollspy';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.scrollspy';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var Default = {
              offset: 10,
              method: 'auto',
              target: ''
          };
          var DefaultType = {
              offset: 'number',
              method: 'string',
              target: '(string|element)'
          };
          var Event = {
              ACTIVATE: "activate" + EVENT_KEY,
              SCROLL: "scroll" + EVENT_KEY,
              LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              DROPDOWN_ITEM: 'dropdown-item',
              DROPDOWN_MENU: 'dropdown-menu',
              ACTIVE: 'active'
          };
          var Selector = {
              DATA_SPY: '[data-spy="scroll"]',
              ACTIVE: '.active',
              NAV_LIST_GROUP: '.nav, .list-group',
              NAV_LINKS: '.nav-link',
              NAV_ITEMS: '.nav-item',
              LIST_ITEMS: '.list-group-item',
              DROPDOWN: '.dropdown',
              DROPDOWN_ITEMS: '.dropdown-item',
              DROPDOWN_TOGGLE: '.dropdown-toggle'
          };
          var OffsetMethod = {
              OFFSET: 'offset',
              POSITION: 'position'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var ScrollSpy =
              /*#__PURE__*/
              function() {
                  function ScrollSpy(element, config) {
                      var _this = this;
  
                      this._element = element;
                      this._scrollElement = element.tagName === 'BODY' ? window : element;
                      this._config = this._getConfig(config);
                      this._selector = this._config.target + " " + Selector.NAV_LINKS + "," + (this._config.target + " " + Selector.LIST_ITEMS + ",") + (this._config.target + " " + Selector.DROPDOWN_ITEMS);
                      this._offsets = [];
                      this._targets = [];
                      this._activeTarget = null;
                      this._scrollHeight = 0;
                      $$$1(this._scrollElement).on(Event.SCROLL, function(event) {
                          return _this._process(event);
                      });
                      this.refresh();
  
                      this._process();
                  } // Getters
  
  
                  var _proto = ScrollSpy.prototype;
  
                  // Public
                  _proto.refresh = function refresh() {
                      var _this2 = this;
  
                      var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
                      var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
                      var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
                      this._offsets = [];
                      this._targets = [];
                      this._scrollHeight = this._getScrollHeight();
                      var targets = $$$1.makeArray($$$1(this._selector));
                      targets.map(function(element) {
                          var target;
                          var targetSelector = Util.getSelectorFromElement(element);
  
                          if (targetSelector) {
                              target = $$$1(targetSelector)[0];
                          }
  
                          if (target) {
                              var targetBCR = target.getBoundingClientRect();
  
                              if (targetBCR.width || targetBCR.height) {
                                  // TODO (fat): remove sketch reliance on jQuery position/offset
                                  return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
                              }
                          }
  
                          return null;
                      }).filter(function(item) {
                          return item;
                      }).sort(function(a, b) {
                          return a[0] - b[0];
                      }).forEach(function(item) {
                          _this2._offsets.push(item[0]);
  
                          _this2._targets.push(item[1]);
                      });
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      $$$1(this._scrollElement).off(EVENT_KEY);
                      this._element = null;
                      this._scrollElement = null;
                      this._config = null;
                      this._selector = null;
                      this._offsets = null;
                      this._targets = null;
                      this._activeTarget = null;
                      this._scrollHeight = null;
                  }; // Private
  
  
                  _proto._getConfig = function _getConfig(config) {
                      config = _extends({}, Default, config);
  
                      if (typeof config.target !== 'string') {
                          var id = $$$1(config.target).attr('id');
  
                          if (!id) {
                              id = Util.getUID(NAME);
                              $$$1(config.target).attr('id', id);
                          }
  
                          config.target = "#" + id;
                      }
  
                      Util.typeCheckConfig(NAME, config, DefaultType);
                      return config;
                  };
  
                  _proto._getScrollTop = function _getScrollTop() {
                      return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
                  };
  
                  _proto._getScrollHeight = function _getScrollHeight() {
                      return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
                  };
  
                  _proto._getOffsetHeight = function _getOffsetHeight() {
                      return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
                  };
  
                  _proto._process = function _process() {
                      var scrollTop = this._getScrollTop() + this._config.offset;
  
                      var scrollHeight = this._getScrollHeight();
  
                      var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
  
                      if (this._scrollHeight !== scrollHeight) {
                          this.refresh();
                      }
  
                      if (scrollTop >= maxScroll) {
                          var target = this._targets[this._targets.length - 1];
  
                          if (this._activeTarget !== target) {
                              this._activate(target);
                          }
  
                          return;
                      }
  
                      if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
                          this._activeTarget = null;
  
                          this._clear();
  
                          return;
                      }
  
                      for (var i = this._offsets.length; i--;) {
                          var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
  
                          if (isActiveTarget) {
                              this._activate(this._targets[i]);
                          }
                      }
                  };
  
                  _proto._activate = function _activate(target) {
                      this._activeTarget = target;
  
                      this._clear();
  
                      var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style
  
  
                      queries = queries.map(function(selector) {
                          return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
                      });
                      var $link = $$$1(queries.join(','));
  
                      if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
                          $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
                          $link.addClass(ClassName.ACTIVE);
                      } else {
                          // Set triggered link as active
                          $link.addClass(ClassName.ACTIVE); // Set triggered links parents as active
                          // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
  
                          $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_LINKS + ", " + Selector.LIST_ITEMS).addClass(ClassName.ACTIVE); // Handle special case when .nav-link is inside .nav-item
  
                          $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE);
                      }
  
                      $$$1(this._scrollElement).trigger(Event.ACTIVATE, {
                          relatedTarget: target
                      });
                  };
  
                  _proto._clear = function _clear() {
                      $$$1(this._selector).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
                  }; // Static
  
  
                  ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = typeof config === 'object' && config;
  
                          if (!data) {
                              data = new ScrollSpy(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(ScrollSpy, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }]);
  
                  return ScrollSpy;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(window).on(Event.LOAD_DATA_API, function() {
              var scrollSpys = $$$1.makeArray($$$1(Selector.DATA_SPY));
  
              for (var i = scrollSpys.length; i--;) {
                  var $spy = $$$1(scrollSpys[i]);
  
                  ScrollSpy._jQueryInterface.call($spy, $spy.data());
              }
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = ScrollSpy._jQueryInterface;
          $$$1.fn[NAME].Constructor = ScrollSpy;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return ScrollSpy._jQueryInterface;
          };
  
          return ScrollSpy;
      }($);
  
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0): tab.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Tab = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = 'tab';
          var VERSION = '4.0.0';
          var DATA_KEY = 'bs.tab';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var TRANSITION_DURATION = 150;
          var Event = {
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
          };
          var ClassName = {
              DROPDOWN_MENU: 'dropdown-menu',
              ACTIVE: 'active',
              DISABLED: 'disabled',
              FADE: 'fade',
              SHOW: 'show'
          };
          var Selector = {
              DROPDOWN: '.dropdown',
              NAV_LIST_GROUP: '.nav, .list-group',
              ACTIVE: '.active',
              ACTIVE_UL: '> li > .active',
              DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
              DROPDOWN_TOGGLE: '.dropdown-toggle',
              DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Tab =
              /*#__PURE__*/
              function() {
                  function Tab(element) {
                      this._element = element;
                  } // Getters
  
  
                  var _proto = Tab.prototype;
  
                  // Public
                  _proto.show = function show() {
                      var _this = this;
  
                      if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
                          return;
                      }
  
                      var target;
                      var previous;
                      var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0];
                      var selector = Util.getSelectorFromElement(this._element);
  
                      if (listElement) {
                          var itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE;
                          previous = $$$1.makeArray($$$1(listElement).find(itemSelector));
                          previous = previous[previous.length - 1];
                      }
  
                      var hideEvent = $$$1.Event(Event.HIDE, {
                          relatedTarget: this._element
                      });
                      var showEvent = $$$1.Event(Event.SHOW, {
                          relatedTarget: previous
                      });
  
                      if (previous) {
                          $$$1(previous).trigger(hideEvent);
                      }
  
                      $$$1(this._element).trigger(showEvent);
  
                      if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      if (selector) {
                          target = $$$1(selector)[0];
                      }
  
                      this._activate(this._element, listElement);
  
                      var complete = function complete() {
                          var hiddenEvent = $$$1.Event(Event.HIDDEN, {
                              relatedTarget: _this._element
                          });
                          var shownEvent = $$$1.Event(Event.SHOWN, {
                              relatedTarget: previous
                          });
                          $$$1(previous).trigger(hiddenEvent);
                          $$$1(_this._element).trigger(shownEvent);
                      };
  
                      if (target) {
                          this._activate(target, target.parentNode, complete);
                      } else {
                          complete();
                      }
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      this._element = null;
                  }; // Private
  
  
                  _proto._activate = function _activate(element, container, callback) {
                      var _this2 = this;
  
                      var activeElements;
  
                      if (container.nodeName === 'UL') {
                          activeElements = $$$1(container).find(Selector.ACTIVE_UL);
                      } else {
                          activeElements = $$$1(container).children(Selector.ACTIVE);
                      }
  
                      var active = activeElements[0];
                      var isTransitioning = callback && Util.supportsTransitionEnd() && active && $$$1(active).hasClass(ClassName.FADE);
  
                      var complete = function complete() {
                          return _this2._transitionComplete(element, active, callback);
                      };
  
                      if (active && isTransitioning) {
                          $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
                      } else {
                          complete();
                      }
                  };
  
                  _proto._transitionComplete = function _transitionComplete(element, active, callback) {
                      if (active) {
                          $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
                          var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
  
                          if (dropdownChild) {
                              $$$1(dropdownChild).removeClass(ClassName.ACTIVE);
                          }
  
                          if (active.getAttribute('role') === 'tab') {
                              active.setAttribute('aria-selected', false);
                          }
                      }
  
                      $$$1(element).addClass(ClassName.ACTIVE);
  
                      if (element.getAttribute('role') === 'tab') {
                          element.setAttribute('aria-selected', true);
                      }
  
                      Util.reflow(element);
                      $$$1(element).addClass(ClassName.SHOW);
  
                      if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
                          var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0];
  
                          if (dropdownElement) {
                              $$$1(dropdownElement).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
                          }
  
                          element.setAttribute('aria-expanded', true);
                      }
  
                      if (callback) {
                          callback();
                      }
                  }; // Static
  
  
                  Tab._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $this = $$$1(this);
                          var data = $this.data(DATA_KEY);
  
                          if (!data) {
                              data = new Tab(this);
                              $this.data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (typeof data[config] === 'undefined') {
                                  throw new TypeError("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  _createClass(Tab, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }]);
  
                  return Tab;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function(event) {
              event.preventDefault();
  
              Tab._jQueryInterface.call($$$1(this), 'show');
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Tab._jQueryInterface;
          $$$1.fn[NAME].Constructor = Tab;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Tab._jQueryInterface;
          };
  
          return Tab;
      }($);
  
      var Util$2 = function() {
          /**
           * ------------------------------------------------------------------------
           * Private TransitionEnd Helpers
           * ------------------------------------------------------------------------
           */
          var transitionEnd = false;
          var _transitionEndSelector = "";
          var TransitionEndEvent = {
              WebkitTransition: "webkitTransitionEnd",
              MozTransition: "transitionend",
              OTransition: "oTransitionEnd otransitionend",
              transition: "transitionend"
          };
  
          function transitionEndTest() {
              if (window.QUnit) {
                  return false;
              }
  
              var el = document.createElement("bmd");
  
              for (var name in TransitionEndEvent) {
                  if (el.style[name] !== undefined) {
                      return TransitionEndEvent[name]; // { end: TransitionEndEvent[name] }
                  }
              }
  
              return false;
          }
  
          function setTransitionEndSupport() {
              transitionEnd = transitionEndTest(); // generate a concatenated transition end event selector
  
              for (var name in TransitionEndEvent) {
                  _transitionEndSelector += " " + TransitionEndEvent[name];
              }
          }
          /**
           * --------------------------------------------------------------------------
           * Public Util Api
           * --------------------------------------------------------------------------
           */
  
  
          var Util = {
              transitionEndSupported: function transitionEndSupported() {
                  return transitionEnd;
              },
              transitionEndSelector: function transitionEndSelector() {
                  return _transitionEndSelector;
              },
              isChar: function isChar(event) {
                  if (typeof event.which === "undefined") {
                      return true;
                  } else if (typeof event.which === "number" && event.which > 0) {
                      return !event.ctrlKey && !event.metaKey && !event.altKey && event.which !== 8 && // backspace
                          event.which !== 9 && // tab
                          event.which !== 13 && // enter
                          event.which !== 16 && // shift
                          event.which !== 17 && // ctrl
                          event.which !== 20 && // caps lock
                          event.which !== 27 // escape
                      ;
                  }
  
                  return false;
              },
              assert: function assert($element, invalidTest, message) {
                  if (invalidTest) {
                      if (!$element === undefined) {
                          $element.css("border", "1px solid red");
                      }
  
                      console.error(message, $element); // eslint-disable-line no-console
  
                      throw message;
                  }
              },
              describe: function describe($element) {
                  if ($element === undefined) {
                      return "undefined";
                  } else if ($element.length === 0) {
                      return "(no matching elements)";
                  }
  
                  return $element[0].outerHTML.split(">")[0] + ">";
              }
          };
          setTransitionEndSupport();
          return Util;
      }(jQuery);
  
      var Base = function($$$1) {
          var ClassName = {
              BMD_FORM_GROUP: "bmd-form-group",
              IS_FILLED: "is-filled",
              IS_FOCUSED: "is-focused"
          };
          var Selector = {
              BMD_FORM_GROUP: "." + ClassName.BMD_FORM_GROUP
          };
          var Default = {};
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Base =
              /*#__PURE__*/
              function() {
                  /**
                   *
                   * @param element
                   * @param config
                   * @param properties - anything that needs to be set as this[key] = value.  Works around the need to call `super` before using `this`
                   */
                  function Base($element, config, properties) {
                      if (properties === void 0) {
                          properties = {};
                      }
  
                      this.$element = $element;
                      this.config = $$$1.extend(true, {}, Default, config); // set properties for use in the constructor initialization
  
                      for (var key in properties) {
                          this[key] = properties[key];
                      }
                  }
  
                  var _proto = Base.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      this.$element.data(dataKey, null);
                      this.$element = null;
                      this.config = null;
                  }; // ------------------------------------------------------------------------
                  // protected
  
  
                  _proto.addFormGroupFocus = function addFormGroupFocus() {
                      if (!this.$element.prop("disabled")) {
                          this.$bmdFormGroup.addClass(ClassName.IS_FOCUSED);
                      }
                  };
  
                  _proto.removeFormGroupFocus = function removeFormGroupFocus() {
                      this.$bmdFormGroup.removeClass(ClassName.IS_FOCUSED);
                  };
  
                  _proto.removeIsFilled = function removeIsFilled() {
                      this.$bmdFormGroup.removeClass(ClassName.IS_FILLED);
                  };
  
                  _proto.addIsFilled = function addIsFilled() {
                      this.$bmdFormGroup.addClass(ClassName.IS_FILLED);
                  }; // Find bmd-form-group
  
  
                  _proto.findMdbFormGroup = function findMdbFormGroup(raiseError) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      var mfg = this.$element.closest(Selector.BMD_FORM_GROUP);
  
                      if (mfg.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.BMD_FORM_GROUP + " for " + Util$2.describe(this.$element));
                      }
  
                      return mfg;
                  }; // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  return Base;
              }();
  
          return Base;
      }(jQuery);
  
      var BaseInput = function($$$1) {
          var ClassName = {
              FORM_GROUP: "form-group",
              BMD_FORM_GROUP: "bmd-form-group",
              BMD_LABEL: "bmd-label",
              BMD_LABEL_STATIC: "bmd-label-static",
              BMD_LABEL_PLACEHOLDER: "bmd-label-placeholder",
              BMD_LABEL_FLOATING: "bmd-label-floating",
              HAS_DANGER: "has-danger",
              IS_FILLED: "is-filled",
              IS_FOCUSED: "is-focused",
              INPUT_GROUP: "input-group"
          };
          var Selector = {
              FORM_GROUP: "." + ClassName.FORM_GROUP,
              BMD_FORM_GROUP: "." + ClassName.BMD_FORM_GROUP,
              BMD_LABEL_WILDCARD: "label[class^='" + ClassName.BMD_LABEL + "'], label[class*=' " + ClassName.BMD_LABEL + "']" // match any label variant if specified
  
          };
          var Default = {
              validate: false,
              formGroup: {
                  required: false
              },
              bmdFormGroup: {
                  template: "<span class='" + ClassName.BMD_FORM_GROUP + "'></span>",
                  create: true,
                  // create a wrapper if form-group not found
                  required: true // not recommended to turn this off, only used for inline components
  
              },
              label: {
                  required: false,
                  // Prioritized find order for resolving the label to be used as an bmd-label if not specified in the markup
                  //  - a function(thisComponent); or
                  //  - a string selector used like $bmdFormGroup.find(selector)
                  //
                  // Note this only runs if $bmdFormGroup.find(Selector.BMD_LABEL_WILDCARD) fails to find a label (as authored in the markup)
                  //
                  selectors: [".form-control-label", // in the case of horizontal or inline forms, this will be marked
                      "> label" // usual case for text inputs, first child.  Deeper would find toggle labels so don't do that.
                  ],
                  className: ClassName.BMD_LABEL_STATIC
              },
              requiredClasses: [],
              invalidComponentMatches: [],
              convertInputSizeVariations: true
          };
          var FormControlSizeMarkers = {
              "form-control-lg": "bmd-form-group-lg",
              "form-control-sm": "bmd-form-group-sm"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var BaseInput =
              /*#__PURE__*/
              function(_Base) {
                  _inheritsLoose(BaseInput, _Base);
  
                  /**
                   *
                   * @param element
                   * @param config
                   * @param properties - anything that needs to be set as this[key] = value.  Works around the need to call `super` before using `this`
                   */
                  function BaseInput($element, config, properties) {
                      var _this;
  
                      if (properties === void 0) {
                          properties = {};
                      }
  
                      _this = _Base.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this; // Enforce no overlap between components to prevent side effects
  
                      _this._rejectInvalidComponentMatches(); // Enforce expected structure (if any)
  
  
                      _this.rejectWithoutRequiredStructure(); // Enforce required classes for a consistent rendering
  
  
                      _this._rejectWithoutRequiredClasses(); // Resolve the form-group first, it will be used for bmd-form-group if possible
                      //   note: different components have different rules
  
  
                      _this.$formGroup = _this.findFormGroup(_this.config.formGroup.required); // Will add bmd-form-group to form-group or create an bmd-form-group
                      //  Performance Note: for those forms that are really performance driven, create the markup with the .bmd-form-group to avoid
                      //    rendering changes once added.
  
                      _this.$bmdFormGroup = _this.resolveMdbFormGroup(); // Resolve and mark the bmdLabel if necessary as defined by the config
  
                      _this.$bmdLabel = _this.resolveMdbLabel(); // Signal to the bmd-form-group that a form-control-* variation is being used
  
                      _this.resolveMdbFormGroupSizing();
  
                      _this.addFocusListener();
  
                      _this.addChangeListener();
  
                      if (_this.$element.val() != "") {
                          _this.addIsFilled();
                      }
  
                      return _this;
                  }
  
                  var _proto = BaseInput.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      _Base.prototype.dispose.call(this, dataKey);
  
                      this.$bmdFormGroup = null;
                      this.$formGroup = null;
                  }; // ------------------------------------------------------------------------
                  // protected
  
  
                  _proto.rejectWithoutRequiredStructure = function rejectWithoutRequiredStructure() { // implement
                  };
  
                  _proto.addFocusListener = function addFocusListener() {
                      var _this2 = this;
  
                      this.$element.on("focus", function() {
                          _this2.addFormGroupFocus();
                      }).on("blur", function() {
                          _this2.removeFormGroupFocus();
                      });
                  };
  
                  _proto.addChangeListener = function addChangeListener() {
                      var _this3 = this;
  
                      this.$element.on("keydown paste", function(event) {
                          if (Util$2.isChar(event)) {
                              _this3.addIsFilled();
                          }
                      }).on("keyup change", function() {
                          // make sure empty is added back when there is a programmatic value change.
                          //  NOTE: programmatic changing of value using $.val() must trigger the change event i.e. $.val('x').trigger('change')
                          if (_this3.isEmpty()) {
                              _this3.removeIsFilled();
                          } else {
                              _this3.addIsFilled();
                          }
  
                          if (_this3.config.validate) {
                              // Validation events do not bubble, so they must be attached directly to the text: http://jsfiddle.net/PEpRM/1/
                              //  Further, even the bind method is being caught, but since we are already calling #checkValidity here, just alter
                              //  the form-group on change.
                              //
                              // NOTE: I'm not sure we should be intervening regarding validation, this seems better as a README and snippet of code.
                              //        BUT, I've left it here for backwards compatibility.
                              var isValid = typeof _this3.$element[0].checkValidity === "undefined" || _this3.$element[0].checkValidity();
  
                              if (isValid) {
                                  _this3.removeHasDanger();
                              } else {
                                  _this3.addHasDanger();
                              }
                          }
                      });
                  };
  
                  _proto.addHasDanger = function addHasDanger() {
                      this.$bmdFormGroup.addClass(ClassName.HAS_DANGER);
                  };
  
                  _proto.removeHasDanger = function removeHasDanger() {
                      this.$bmdFormGroup.removeClass(ClassName.HAS_DANGER);
                  };
  
                  _proto.isEmpty = function isEmpty() {
                      return this.$element.val() === null || this.$element.val() === undefined || this.$element.val() === "";
                  }; // Will add bmd-form-group to form-group or create a bmd-form-group if necessary
  
  
                  _proto.resolveMdbFormGroup = function resolveMdbFormGroup() {
                      var mfg = this.findMdbFormGroup(false);
  
                      if (mfg === undefined || mfg.length === 0) {
                          if (this.config.bmdFormGroup.create && (this.$formGroup === undefined || this.$formGroup.length === 0)) {
                              // If a form-group doesn't exist (not recommended), take a guess and wrap the element (assuming no label).
                              //  note: it's possible to make this smarter, but I need to see valid cases before adding any complexity.
                              // this may be an input-group, wrap that instead
                              if (this.outerElement().parent().hasClass(ClassName.INPUT_GROUP)) {
                                  this.outerElement().parent().wrap(this.config.bmdFormGroup.template);
                              } else {
                                  this.outerElement().wrap(this.config.bmdFormGroup.template);
                              }
                          } else {
                              // a form-group does exist, add our marker class to it
                              this.$formGroup.addClass(ClassName.BMD_FORM_GROUP); // OLD: may want to implement this after all, see how the styling turns out, but using an existing form-group is less manipulation of the dom and therefore preferable
                              // A form-group does exist, so add an bmd-form-group wrapping it's internal contents
                              //fg.wrapInner(this.config.bmdFormGroup.template)
                          }
  
                          mfg = this.findMdbFormGroup(this.config.bmdFormGroup.required);
                      }
  
                      return mfg;
                  }; // Demarcation element (e.g. first child of a form-group)
                  //  Subclasses such as file inputs may have different structures
  
  
                  _proto.outerElement = function outerElement() {
                      return this.$element;
                  }; // Will add bmd-label to bmd-form-group if not already specified
  
  
                  _proto.resolveMdbLabel = function resolveMdbLabel() {
                      var label = this.$bmdFormGroup.find(Selector.BMD_LABEL_WILDCARD);
  
                      if (label === undefined || label.length === 0) {
                          // we need to find it based on the configured selectors
                          label = this.findMdbLabel(this.config.label.required);
  
                          if (label === undefined || label.length === 0) { // no label found, and finder did not require one
                          } else {
                              // a candidate label was found, add the configured default class name
                              label.addClass(this.config.label.className);
                          }
                      }
  
                      return label;
                  }; // Find bmd-label variant based on the config selectors
  
  
                  _proto.findMdbLabel = function findMdbLabel(raiseError) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      var label = null; // use the specified selector order
  
                      for (var _iterator = this.config.label.selectors, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                          var _ref;
  
                          if (_isArray) {
                              if (_i >= _iterator.length) break;
                              _ref = _iterator[_i++];
                          } else {
                              _i = _iterator.next();
                              if (_i.done) break;
                              _ref = _i.value;
                          }
  
                          var _selector = _ref;
  
                          if ($$$1.isFunction(_selector)) {
                              label = _selector(this);
                          } else {
                              label = this.$bmdFormGroup.find(_selector);
                          }
  
                          if (label !== undefined && label.length > 0) {
                              break;
                          }
                      }
  
                      if (label.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.BMD_LABEL_WILDCARD + " within form-group for " + Util$2.describe(this.$element));
                      }
  
                      return label;
                  }; // Find bmd-form-group
  
  
                  _proto.findFormGroup = function findFormGroup(raiseError) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      var fg = this.$element.closest(Selector.FORM_GROUP);
  
                      if (fg.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.FORM_GROUP + " for " + Util$2.describe(this.$element));
                      }
  
                      return fg;
                  }; // Due to the interconnected nature of labels/inputs/help-blocks, signal the bmd-form-group-* size variation based on
                  //  a found form-control-* size
  
  
                  _proto.resolveMdbFormGroupSizing = function resolveMdbFormGroupSizing() {
                      if (!this.config.convertInputSizeVariations) {
                          return;
                      } // Modification - Change text-sm/lg to form-group-sm/lg instead (preferred standard and simpler css/less variants)
  
  
                      for (var inputSize in FormControlSizeMarkers) {
                          if (this.$element.hasClass(inputSize)) {
                              //this.$element.removeClass(inputSize)
                              this.$bmdFormGroup.addClass(FormControlSizeMarkers[inputSize]);
                          }
                      }
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  _proto._rejectInvalidComponentMatches = function _rejectInvalidComponentMatches() {
                      for (var _iterator2 = this.config.invalidComponentMatches, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                          var _ref2;
  
                          if (_isArray2) {
                              if (_i2 >= _iterator2.length) break;
                              _ref2 = _iterator2[_i2++];
                          } else {
                              _i2 = _iterator2.next();
                              if (_i2.done) break;
                              _ref2 = _i2.value;
                          }
  
                          var _otherComponent = _ref2;
  
                          _otherComponent.rejectMatch(this.constructor.name, this.$element);
                      }
                  };
  
                  _proto._rejectWithoutRequiredClasses = function _rejectWithoutRequiredClasses() {
                      for (var _iterator3 = this.config.requiredClasses, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
                          var _ref3;
  
                          if (_isArray3) {
                              if (_i3 >= _iterator3.length) break;
                              _ref3 = _iterator3[_i3++];
                          } else {
                              _i3 = _iterator3.next();
                              if (_i3.done) break;
                              _ref3 = _i3.value;
                          }
  
                          var _requiredClass = _ref3;
                          var found = false; // allow one of several classes to be passed in x||y
  
                          if (_requiredClass.indexOf("||") !== -1) {
                              var oneOf = _requiredClass.split("||");
  
                              for (var _iterator4 = oneOf, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
                                  var _ref4;
  
                                  if (_isArray4) {
                                      if (_i4 >= _iterator4.length) break;
                                      _ref4 = _iterator4[_i4++];
                                  } else {
                                      _i4 = _iterator4.next();
                                      if (_i4.done) break;
                                      _ref4 = _i4.value;
                                  }
  
                                  var _requiredClass3 = _ref4;
  
                                  if (this.$element.hasClass(_requiredClass3)) {
                                      found = true;
                                      break;
                                  }
                              }
                          } else if (this.$element.hasClass(_requiredClass)) {
                              found = true;
                          } // error if not found
  
  
                          if (!found) {
                              $$$1.error(this.constructor.name + " element: " + Util$2.describe(this.$element) + " requires class: " + _requiredClass);
                          }
                      }
                  }; // ------------------------------------------------------------------------
                  // static
  
  
                  return BaseInput;
              }(Base);
  
          return BaseInput;
      }(jQuery);
  
      var BaseSelection = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var Default = {
              label: {
                  required: false // Prioritized find order for resolving the label to be used as an bmd-label if not specified in the markup
                  //  - a function(thisComponent); or
                  //  - a string selector used like $bmdFormGroup.find(selector)
                  //
                  // Note this only runs if $bmdFormGroup.find(Selector.BMD_LABEL_WILDCARD) fails to find a label (as authored in the markup)
                  //
                  //selectors: [
                  //  `.form-control-label`, // in the case of horizontal or inline forms, this will be marked
                  //  `> label` // usual case for text inputs
                  //]
  
              }
          };
          var Selector = {
              LABEL: "label"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var BaseSelection =
              /*#__PURE__*/
              function(_BaseInput) {
                  _inheritsLoose(BaseSelection, _BaseInput);
  
                  function BaseSelection($element, config, properties) {
                      var _this;
  
                      // properties = {inputType: checkbox, outerClass: checkbox-inline}
                      // '.checkbox|switch|radio > label > input[type=checkbox|radio]'
                      // '.${this.outerClass} > label > input[type=${this.inputType}]'
                      _this = _BaseInput.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this;
  
                      _this.decorateMarkup();
  
                      return _this;
                  } // ------------------------------------------------------------------------
                  // protected
  
  
                  var _proto = BaseSelection.prototype;
  
                  _proto.decorateMarkup = function decorateMarkup() {
                      var $decorator = $$$1(this.config.template);
                      this.$element.after($decorator); // initialize ripples after decorator has been inserted into DOM
  
                      if (this.config.ripples !== false) {
                          $decorator.bmdRipples();
                      }
                  }; // Demarcation element (e.g. first child of a form-group)
  
  
                  _proto.outerElement = function outerElement() {
                      // .checkbox|switch|radio > label > input[type=checkbox|radio]
                      // label.checkbox-inline > input[type=checkbox|radio]
                      // .${this.outerClass} > label > input[type=${this.inputType}]
                      return this.$element.parent().closest("." + this.outerClass);
                  };
  
                  _proto.rejectWithoutRequiredStructure = function rejectWithoutRequiredStructure() {
                      // '.checkbox|switch|radio > label > input[type=checkbox|radio]'
                      // '.${this.outerClass} > label > input[type=${this.inputType}]'
                      Util$2.assert(this.$element, !this.$element.parent().prop("tagName") === "label", this.constructor.name + "'s " + Util$2.describe(this.$element) + " parent element should be <label>.");
                      Util$2.assert(this.$element, !this.outerElement().hasClass(this.outerClass), this.constructor.name + "'s " + Util$2.describe(this.$element) + " outer element should have class " + this.outerClass + ".");
                  };
  
                  _proto.addFocusListener = function addFocusListener() {
                      var _this2 = this;
  
                      // checkboxes didn't appear to bubble to the document, so we'll bind these directly
                      this.$element.closest(Selector.LABEL).hover(function() {
                          _this2.addFormGroupFocus();
                      }, function() {
                          _this2.removeFormGroupFocus();
                      });
                  };
  
                  _proto.addChangeListener = function addChangeListener() {
                      var _this3 = this;
  
                      this.$element.change(function() {
                          _this3.$element.blur();
                      });
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  return BaseSelection;
              }(BaseInput);
  
          return BaseSelection;
      }(jQuery);
  
      //import File from './file'
      //import Radio from './radio'
      //import Textarea from './textarea'
      //import Select from './select'
  
      var Checkbox = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "checkbox";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              template: "<span class='checkbox-decorator'><span class='check'></span></span>"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Checkbox =
              /*#__PURE__*/
              function(_BaseSelection) {
                  _inheritsLoose(Checkbox, _BaseSelection);
  
                  function Checkbox($element, config, properties) {
                      if (properties === void 0) {
                          properties = {
                              inputType: NAME,
                              outerClass: NAME
                          };
                      }
  
                      return _BaseSelection.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [File, Radio, Text, Textarea, Select]},
                          Default, config), properties) || this;
                  }
  
                  var _proto = Checkbox.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      if (dataKey === void 0) {
                          dataKey = DATA_KEY;
                      }
  
                      _BaseSelection.prototype.dispose.call(this, dataKey);
                  };
  
                  Checkbox.matches = function matches($element) {
                      // '.checkbox > label > input[type=checkbox]'
                      if ($element.attr("type") === "checkbox") {
                          return true;
                      }
  
                      return false;
                  };
  
                  Checkbox.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for type='checkbox'.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Checkbox._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Checkbox($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Checkbox;
              }(BaseSelection);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Checkbox._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Checkbox;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Checkbox._jQueryInterface;
          };
  
          return Checkbox;
      }(jQuery);
  
      var CheckboxInline = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "checkboxInline";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              bmdFormGroup: {
                  create: false,
                  // no bmd-form-group creation if form-group not present. It messes with the layout.
                  required: false
              }
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var CheckboxInline =
              /*#__PURE__*/
              function(_Checkbox) {
                  _inheritsLoose(CheckboxInline, _Checkbox);
  
                  function CheckboxInline($element, config, properties) {
                      if (properties === void 0) {
                          properties = {
                              inputType: "checkbox",
                              outerClass: "checkbox-inline"
                          };
                      }
  
                      return _Checkbox.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this;
                  }
  
                  var _proto = CheckboxInline.prototype;
  
                  _proto.dispose = function dispose() {
                      _Checkbox.prototype.dispose.call(this, DATA_KEY);
                  }; //static matches($element) {
                  //  // '.checkbox-inline > input[type=checkbox]'
                  //  if ($element.attr('type') === 'checkbox') {
                  //    return true
                  //  }
                  //  return false
                  //}
                  //
                  //static rejectMatch(component, $element) {
                  //  Util.assert(this.$element, this.matches($element), `${component} component element ${Util.describe($element)} is invalid for type='checkbox'.`)
                  //}
                  // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  CheckboxInline._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new CheckboxInline($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return CheckboxInline;
              }(Checkbox);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = CheckboxInline._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = CheckboxInline;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return CheckboxInline._jQueryInterface;
          };
  
          return CheckboxInline;
      }(jQuery);
  
      var CollapseInline = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "collapseInline";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Selector = {
              ANY_INPUT: "input, select, textarea"
          };
          var ClassName = {
              IN: "in",
              COLLAPSE: "collapse",
              COLLAPSING: "collapsing",
              COLLAPSED: "collapsed",
              WIDTH: "width"
          };
          var Default = {};
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var CollapseInline =
              /*#__PURE__*/
              function(_Base) {
                  _inheritsLoose(CollapseInline, _Base);
  
                  // $element is expected to be the trigger
                  //  i.e. <button class="btn bmd-btn-icon" for="search" data-toggle="collapse" data-target="#search-field" aria-expanded="false" aria-controls="search-field">
                  function CollapseInline($element, config) {
                      var _this;
  
                      _this = _Base.call(this, $element, $$$1.extend(true, {}, Default, config)) || this;
                      _this.$bmdFormGroup = _this.findMdbFormGroup(true);
                      var collapseSelector = $element.data("target");
                      _this.$collapse = $$$1(collapseSelector);
                      Util$2.assert($element, _this.$collapse.length === 0, "Cannot find collapse target for " + Util$2.describe($element));
                      Util$2.assert(_this.$collapse, !_this.$collapse.hasClass(ClassName.COLLAPSE), Util$2.describe(_this.$collapse) + " is expected to have the '" + ClassName.COLLAPSE + "' class.  It is being targeted by " + Util$2.describe($element)); // find the first input for focusing
  
                      var $inputs = _this.$bmdFormGroup.find(Selector.ANY_INPUT);
  
                      if ($inputs.length > 0) {
                          _this.$input = $inputs.first();
                      } // automatically add the marker class to collapse width instead of height - nice convenience because it is easily forgotten
  
  
                      if (!_this.$collapse.hasClass(ClassName.WIDTH)) {
                          _this.$collapse.addClass(ClassName.WIDTH);
                      }
  
                      if (_this.$input) {
                          // add a listener to set focus
                          _this.$collapse.on("shown.bs.collapse", function() {
                              _this.$input.focus();
                          }); // add a listener to collapse field
  
  
                          _this.$input.blur(function() {
                              _this.$collapse.collapse("hide");
                          });
                      }
  
                      return _this;
                  }
  
                  var _proto = CollapseInline.prototype;
  
                  _proto.dispose = function dispose() {
                      _Base.prototype.dispose.call(this, DATA_KEY);
  
                      this.$bmdFormGroup = null;
                      this.$collapse = null;
                      this.$input = null;
                  }; // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  CollapseInline._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new CollapseInline($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return CollapseInline;
              }(Base);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = CollapseInline._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = CollapseInline;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return CollapseInline._jQueryInterface;
          };
  
          return CollapseInline;
      }(jQuery);
  
      //import Radio from './radio'
      //import Switch from './switch'
      //import Text from './text'
      //import Textarea from './textarea'
      //import Select from './select'
  
      var File = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "file";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {};
          var ClassName = {
              FILE: NAME,
              IS_FILE: "is-file"
          };
          var Selector = {
              FILENAMES: "input.form-control[readonly]"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var File =
              /*#__PURE__*/
              function(_BaseInput) {
                  _inheritsLoose(File, _BaseInput);
  
                  function File($element, config) {
                      var _this;
  
                      _this = _BaseInput.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [Checkbox, Radio, Text, Textarea, Select, Switch]},
                          Default, config)) || this;
  
                      _this.$bmdFormGroup.addClass(ClassName.IS_FILE);
  
                      return _this;
                  }
  
                  var _proto = File.prototype;
  
                  _proto.dispose = function dispose() {
                      _BaseInput.prototype.dispose.call(this, DATA_KEY);
                  };
  
                  File.matches = function matches($element) {
                      if ($element.attr("type") === "file") {
                          return true;
                      }
  
                      return false;
                  };
  
                  File.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for type='file'.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  // Demarcation element (e.g. first child of a form-group)
  
  
                  _proto.outerElement = function outerElement() {
                      // label.file > input[type=file]
                      return this.$element.parent().closest("." + ClassName.FILE);
                  };
  
                  _proto.rejectWithoutRequiredStructure = function rejectWithoutRequiredStructure() {
                      // label.file > input[type=file]
                      Util$2.assert(this.$element, !this.outerElement().prop("tagName") === "label", this.constructor.name + "'s " + Util$2.describe(this.$element) + " parent element " + Util$2.describe(this.outerElement()) + " should be <label>.");
                      Util$2.assert(this.$element, !this.outerElement().hasClass(ClassName.FILE), this.constructor.name + "'s " + Util$2.describe(this.$element) + " parent element " + Util$2.describe(this.outerElement()) + " should have class ." + ClassName.FILE + ".");
                  };
  
                  _proto.addFocusListener = function addFocusListener() {
                      var _this2 = this;
  
                      this.$bmdFormGroup.on("focus", function() {
                          _this2.addFormGroupFocus();
                      }).on("blur", function() {
                          _this2.removeFormGroupFocus();
                      });
                  };
  
                  _proto.addChangeListener = function addChangeListener() {
                      var _this3 = this;
  
                      // set the fileinput readonly field with the name of the file
                      this.$element.on("change", function() {
                          var value = "";
                          $$$1.each(_this3.$element.files, function(i, file) {
                              value += file.name + "  , ";
                          });
                          value = value.substring(0, value.length - 2);
  
                          if (value) {
                              _this3.addIsFilled();
                          } else {
                              _this3.removeIsFilled();
                          }
  
                          _this3.$bmdFormGroup.find(Selector.FILENAMES).val(value);
                      });
                  }; // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  File._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new File($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return File;
              }(BaseInput);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = File._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = File;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return File._jQueryInterface;
          };
  
          return File;
      }(jQuery);
  
      //import File from './file'
      //import Checkbox from './checkbox'
      //import Switch from './switch'
  
      var Radio = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "radio";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              template: "<span class='bmd-radio'></span>"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Radio =
              /*#__PURE__*/
              function(_BaseSelection) {
                  _inheritsLoose(Radio, _BaseSelection);
  
                  function Radio($element, config, properties) {
                      if (properties === void 0) {
                          properties = {
                              inputType: NAME,
                              outerClass: NAME
                          };
                      }
  
                      return _BaseSelection.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [Checkbox, File, Switch, Text]},
                          Default, config), properties) || this;
                  }
  
                  var _proto = Radio.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      if (dataKey === void 0) {
                          dataKey = DATA_KEY;
                      }
  
                      _BaseSelection.prototype.dispose.call(this, dataKey);
                  };
  
                  Radio.matches = function matches($element) {
                      // '.radio > label > input[type=radio]'
                      if ($element.attr("type") === "radio") {
                          return true;
                      }
  
                      return false;
                  };
  
                  Radio.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for type='radio'.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  //decorateMarkup() {
                  //  this.$element.after(this.config.template)
                  //}
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Radio._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Radio($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Radio;
              }(BaseSelection);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Radio._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Radio;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Radio._jQueryInterface;
          };
  
          return Radio;
      }(jQuery);
  
      var RadioInline = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "radioInline";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              bmdFormGroup: {
                  create: false,
                  // no bmd-form-group creation if form-group not present. It messes with the layout.
                  required: false
              }
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var RadioInline =
              /*#__PURE__*/
              function(_Radio) {
                  _inheritsLoose(RadioInline, _Radio);
  
                  function RadioInline($element, config, properties) {
                      if (properties === void 0) {
                          properties = {
                              inputType: "radio",
                              outerClass: "radio-inline"
                          };
                      }
  
                      return _Radio.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this;
                  }
  
                  var _proto = RadioInline.prototype;
  
                  _proto.dispose = function dispose() {
                      _Radio.prototype.dispose.call(this, DATA_KEY);
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  RadioInline._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new RadioInline($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return RadioInline;
              }(Radio);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = RadioInline._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = RadioInline;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return RadioInline._jQueryInterface;
          };
  
          return RadioInline;
      }(jQuery);
  
      var BaseFormControl = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var Default = {
              requiredClasses: ["form-control"]
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var BaseFormControl =
              /*#__PURE__*/
              function(_BaseInput) {
                  _inheritsLoose(BaseFormControl, _BaseInput);
  
                  function BaseFormControl($element, config) {
                      var _this;
  
                      _this = _BaseInput.call(this, $element, $$$1.extend(true, Default, config)) || this; // Initially mark as empty
  
                      if (_this.isEmpty()) {
                          _this.removeIsFilled();
                      }
  
                      return _this;
                  }
  
                  return BaseFormControl;
              }(BaseInput);
  
          return BaseFormControl;
      }(jQuery);
  
      //import File from './file'
      //import Radio from './radio'
      //import Switch from './switch'
      //import Text from './text'
      //import Textarea from './textarea'
  
      var Select = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "select";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              requiredClasses: ["form-control||custom-select"]
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Select =
              /*#__PURE__*/
              function(_BaseFormControl) {
                  _inheritsLoose(Select, _BaseFormControl);
  
                  function Select($element, config) {
                      var _this;
  
                      _this = _BaseFormControl.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [Checkbox, File, Radio, Switch, Text, Textarea]},
                          Default, config)) || this; // floating labels will cover the options, so trigger them to be above (if used)
  
                      _this.addIsFilled();
  
                      return _this;
                  }
  
                  var _proto = Select.prototype;
  
                  _proto.dispose = function dispose() {
                      _BaseFormControl.prototype.dispose.call(this, DATA_KEY);
                  };
  
                  Select.matches = function matches($element) {
                      if ($element.prop("tagName") === "select") {
                          return true;
                      }
  
                      return false;
                  };
  
                  Select.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for <select>.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Select._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Select($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Select;
              }(BaseFormControl);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Select._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Select;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Select._jQueryInterface;
          };
  
          return Select;
      }(jQuery);
  
      var Switch = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "switch";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {
              template: "<span class='bmd-switch-track'></span>"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Switch =
              /*#__PURE__*/
              function(_Checkbox) {
                  _inheritsLoose(Switch, _Checkbox);
  
                  function Switch($element, config, properties) {
                      if (properties === void 0) {
                          properties = {
                              inputType: "checkbox",
                              outerClass: "switch"
                          };
                      }
  
                      return _Checkbox.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this; // selector: '.switch > label > input[type=checkbox]'
                  }
  
                  var _proto = Switch.prototype;
  
                  _proto.dispose = function dispose() {
                      _Checkbox.prototype.dispose.call(this, DATA_KEY);
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Switch._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Switch($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Switch;
              }(Checkbox);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Switch._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Switch;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Switch._jQueryInterface;
          };
  
          return Switch;
      }(jQuery);
  
      //import File from './file'
      //import Radio from './radio'
      //import Switch from './switch'
      //import Textarea from './textarea'
      //import Select from './select'
  
      var Text = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "text";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {};
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Text =
              /*#__PURE__*/
              function(_BaseFormControl) {
                  _inheritsLoose(Text, _BaseFormControl);
  
                  function Text($element, config) {
                      return _BaseFormControl.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [Checkbox, File, Radio, Switch, Select, Textarea]},
                          Default, config)) || this;
                  }
  
                  var _proto = Text.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      if (dataKey === void 0) {
                          dataKey = DATA_KEY;
                      }
  
                      _BaseFormControl.prototype.dispose.call(this, dataKey);
                  };
  
                  Text.matches = function matches($element) {
                      if ($element.attr("type") === "text") {
                          return true;
                      }
  
                      return false;
                  };
  
                  Text.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for type='text'.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Text._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Text($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Text;
              }(BaseFormControl);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Text._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Text;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Text._jQueryInterface;
          };
  
          return Text;
      }(jQuery);
  
      //import File from './file'
      //import Radio from './radio'
      //import Switch from './switch'
      //import Text from './text'
      //import Select from './select'
  
      var Textarea = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "textarea";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {};
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Textarea =
              /*#__PURE__*/
              function(_BaseFormControl) {
                  _inheritsLoose(Textarea, _BaseFormControl);
  
                  function Textarea($element, config) {
                      return _BaseFormControl.call(this, $element, $$$1.extend(true, //{invalidComponentMatches: [Checkbox, File, Radio, Text, Select, Switch]},
                          Default, config)) || this;
                  }
  
                  var _proto = Textarea.prototype;
  
                  _proto.dispose = function dispose() {
                      _BaseFormControl.prototype.dispose.call(this, DATA_KEY);
                  };
  
                  Textarea.matches = function matches($element) {
                      if ($element.prop("tagName") === "textarea") {
                          return true;
                      }
  
                      return false;
                  };
  
                  Textarea.rejectMatch = function rejectMatch(component, $element) {
                      Util$2.assert(this.$element, this.matches($element), component + " component element " + Util$2.describe($element) + " is invalid for <textarea>.");
                  }; // ------------------------------------------------------------------------
                  // protected
                  // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  Textarea._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Textarea($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Textarea;
              }(BaseFormControl);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Textarea._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Textarea;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Textarea._jQueryInterface;
          };
  
          return Textarea;
      }(jQuery);
  
      /* global Popper */
  
      /**
       * This is a copy of the Bootstrap's original dropdown.js, with the only addition
       * of two new classes: 'showing' and 'hiding', used to handle animaitons.
       */
      /**
       * --------------------------------------------------------------------------
       * Bootstrap (v4.0.0-beta): dropdown.js
       * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
       * --------------------------------------------------------------------------
       */
  
      var Dropdown = function($$$1) {
          /**
           * Check for Popper dependency
           * Popper - https://popper.js.org
           */
          if (typeof Popper === 'undefined') {
              throw new Error('Bootstrap dropdown require Popper.js (https://popper.js.org)');
          }
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
  
  
          var NAME = 'dropdown';
          var VERSION = '4.0.0-beta';
          var DATA_KEY = 'bs.dropdown';
          var EVENT_KEY = "." + DATA_KEY;
          var DATA_API_KEY = '.data-api';
          var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
          var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
  
          var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
  
          var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
  
          var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
  
          var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
  
          var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
  
          var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
          var Event = {
              HIDE: "hide" + EVENT_KEY,
              HIDDEN: "hidden" + EVENT_KEY,
              SHOW: "show" + EVENT_KEY,
              SHOWN: "shown" + EVENT_KEY,
              CLICK: "click" + EVENT_KEY,
              CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
              KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
              KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY,
              TRANSITION_END: 'transitionend webkitTransitionEnd oTransitionEnd animationend webkitAnimationEnd oAnimationEnd'
          };
          var ClassName = {
              DISABLED: 'disabled',
              SHOW: 'show',
              SHOWING: 'showing',
              HIDING: 'hiding',
              DROPUP: 'dropup',
              MENURIGHT: 'dropdown-menu-right',
              MENULEFT: 'dropdown-menu-left'
          };
          var Selector = {
              DATA_TOGGLE: '[data-toggle="dropdown"]',
              FORM_CHILD: '.dropdown form',
              MENU: '.dropdown-menu',
              NAVBAR_NAV: '.navbar-nav',
              VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled)'
          };
          var AttachmentMap = {
              TOP: 'top-start',
              TOPEND: 'top-end',
              BOTTOM: 'bottom-start',
              BOTTOMEND: 'bottom-end'
          };
          var Default = {
              placement: AttachmentMap.BOTTOM,
              offset: 0,
              flip: true
          };
          var DefaultType = {
              placement: 'string',
              offset: '(number|string)',
              flip: 'boolean'
              /**
               * ------------------------------------------------------------------------
               * Class Definition
               * ------------------------------------------------------------------------
               */
  
          };
  
          var Dropdown =
              /*#__PURE__*/
              function() {
                  function Dropdown(element, config) {
                      this._element = element;
                      this._popper = null;
                      this._config = this._getConfig(config);
                      this._menu = this._getMenuElement();
                      this._inNavbar = this._detectNavbar();
  
                      this._addEventListeners();
                  } // getters
  
  
                  var _proto = Dropdown.prototype;
  
                  // public
                  _proto.toggle = function toggle() {
                      var _this = this;
  
                      if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
                          return;
                      }
  
                      var parent = Dropdown._getParentFromElement(this._element);
  
                      var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
  
                      Dropdown._clearMenus();
  
                      if (isActive) {
                          return;
                      }
  
                      var relatedTarget = {
                          relatedTarget: this._element
                      };
                      var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
                      $$$1(parent).trigger(showEvent);
  
                      if (showEvent.isDefaultPrevented()) {
                          return;
                      }
  
                      var element = this._element; // for dropup with alignment we use the parent as popper container
  
                      if ($$$1(parent).hasClass(ClassName.DROPUP)) {
                          if ($$$1(this._menu).hasClass(ClassName.MENULEFT) || $$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
                              element = parent;
                          }
                      }
  
                      this._popper = new Popper(element, this._menu, this._getPopperConfig()); // if this is a touch-enabled device we add extra
                      // empty mouseover listeners to the body's immediate children;
                      // only needed because of broken event delegation on iOS
                      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
  
                      if ('ontouchstart' in document.documentElement && !$$$1(parent).closest(Selector.NAVBAR_NAV).length) {
                          $$$1('body').children().on('mouseover', null, $$$1.noop);
                      }
  
                      this._element.focus();
  
                      this._element.setAttribute('aria-expanded', true);
  
                      $$$1(this._menu).one(Event.TRANSITION_END, function() {
                          $$$1(parent).trigger($$$1.Event(Event.SHOWN, relatedTarget));
                          $$$1(_this._menu).removeClass(ClassName.SHOWING);
                      });
                      $$$1(this._menu).addClass(ClassName.SHOW + " " + ClassName.SHOWING);
                      $$$1(parent).addClass(ClassName.SHOW);
                  };
  
                  _proto.dispose = function dispose() {
                      $$$1.removeData(this._element, DATA_KEY);
                      $$$1(this._element).off(EVENT_KEY);
                      this._element = null;
                      this._menu = null;
  
                      if (this._popper !== null) {
                          this._popper.destroy();
                      }
  
                      this._popper = null;
                  };
  
                  _proto.update = function update() {
                      this._inNavbar = this._detectNavbar();
  
                      if (this._popper !== null) {
                          this._popper.scheduleUpdate();
                      }
                  }; // private
  
  
                  _proto._addEventListeners = function _addEventListeners() {
                      var _this2 = this;
  
                      $$$1(this._element).on(Event.CLICK, function(event) {
                          event.preventDefault();
                          event.stopPropagation();
  
                          _this2.toggle();
                      });
                  };
  
                  _proto._getConfig = function _getConfig(config) {
                      var elementData = $$$1(this._element).data();
  
                      if (elementData.placement !== undefined) {
                          elementData.placement = AttachmentMap[elementData.placement.toUpperCase()];
                      }
  
                      config = $$$1.extend({}, this.constructor.Default, $$$1(this._element).data(), config);
                      Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
                      return config;
                  };
  
                  _proto._getMenuElement = function _getMenuElement() {
                      if (!this._menu) {
                          var parent = Dropdown._getParentFromElement(this._element);
  
                          this._menu = $$$1(parent).find(Selector.MENU)[0];
                      }
  
                      return this._menu;
                  };
  
                  _proto._getPlacement = function _getPlacement() {
                      var $parentDropdown = $$$1(this._element).parent();
                      var placement = this._config.placement; // Handle dropup
  
                      if ($parentDropdown.hasClass(ClassName.DROPUP) || this._config.placement === AttachmentMap.TOP) {
                          placement = AttachmentMap.TOP;
  
                          if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
                              placement = AttachmentMap.TOPEND;
                          }
                      } else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
                          placement = AttachmentMap.BOTTOMEND;
                      }
  
                      return placement;
                  };
  
                  _proto._detectNavbar = function _detectNavbar() {
                      return $$$1(this._element).closest('.navbar').length > 0;
                  };
  
                  _proto._getPopperConfig = function _getPopperConfig() {
                      var popperConfig = {
                          placement: this._getPlacement(),
                          modifiers: {
                              offset: {
                                  offset: this._config.offset
                              },
                              flip: {
                                  enabled: this._config.flip
                              }
                          } // Disable Popper.js for Dropdown in Navbar
  
                      };
  
                      if (this._inNavbar) {
                          popperConfig.modifiers.applyStyle = {
                              enabled: !this._inNavbar
                          };
                      }
  
                      return popperConfig;
                  }; // static
  
  
                  Dropdown._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var data = $$$1(this).data(DATA_KEY);
  
                          var _config = typeof config === 'object' ? config : null;
  
                          if (!data) {
                              data = new Dropdown(this, _config);
                              $$$1(this).data(DATA_KEY, data);
                          }
  
                          if (typeof config === 'string') {
                              if (data[config] === undefined) {
                                  throw new Error("No method named \"" + config + "\"");
                              }
  
                              data[config]();
                          }
                      });
                  };
  
                  Dropdown._clearMenus = function _clearMenus(event) {
                      if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
                          return;
                      }
  
                      var toggles = $$$1.makeArray($$$1(Selector.DATA_TOGGLE));
  
                      var _loop = function _loop(i) {
                          var parent = Dropdown._getParentFromElement(toggles[i]);
  
                          var context = $$$1(toggles[i]).data(DATA_KEY);
                          var relatedTarget = {
                              relatedTarget: toggles[i]
                          };
  
                          if (!context) {
                              return "continue";
                          }
  
                          var dropdownMenu = context._menu;
  
                          if (!$$$1(parent).hasClass(ClassName.SHOW)) {
                              return "continue";
                          }
  
                          if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
                              return "continue";
                          }
  
                          var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
                          $$$1(parent).trigger(hideEvent);
  
                          if (hideEvent.isDefaultPrevented()) {
                              return "continue";
                          } // if this is a touch-enabled device we remove the extra
                          // empty mouseover listeners we added for iOS support
  
  
                          if ('ontouchstart' in document.documentElement) {
                              $$$1('body').children().off('mouseover', null, $$$1.noop);
                          }
  
                          toggles[i].setAttribute('aria-expanded', 'false');
                          $$$1(dropdownMenu).addClass(ClassName.HIDING).removeClass(ClassName.SHOW);
                          $$$1(parent).removeClass(ClassName.SHOW);
                          $$$1(dropdownMenu).one(Event.TRANSITION_END, function() {
                              $$$1(parent).trigger($$$1.Event(Event.HIDDEN, relatedTarget));
                              $$$1(dropdownMenu).removeClass(ClassName.HIDING);
                          });
                      };
  
                      for (var i = 0; i < toggles.length; i++) {
                          var _ret = _loop(i);
  
                          if (_ret === "continue") continue;
                      }
                  };
  
                  Dropdown._getParentFromElement = function _getParentFromElement(element) {
                      var parent;
                      var selector = Util.getSelectorFromElement(element);
  
                      if (selector) {
                          parent = $$$1(selector)[0];
                      }
  
                      return parent || element.parentNode;
                  };
  
                  Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
                      if (!REGEXP_KEYDOWN.test(event.which) || /button/i.test(event.target.tagName) && event.which === SPACE_KEYCODE || /input|textarea/i.test(event.target.tagName)) {
                          return;
                      }
  
                      event.preventDefault();
                      event.stopPropagation();
  
                      if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
                          return;
                      }
  
                      var parent = Dropdown._getParentFromElement(this);
  
                      var isActive = $$$1(parent).hasClass(ClassName.SHOW);
  
                      if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
                          if (event.which === ESCAPE_KEYCODE) {
                              var toggle = $$$1(parent).find(Selector.DATA_TOGGLE)[0];
                              $$$1(toggle).trigger('focus');
                          }
  
                          $$$1(this).trigger('click');
                          return;
                      }
  
                      var items = $$$1(parent).find(Selector.VISIBLE_ITEMS).get();
  
                      if (!items.length) {
                          return;
                      }
  
                      var index = items.indexOf(event.target);
  
                      if (event.which === ARROW_UP_KEYCODE && index > 0) {
                          // up
                          index--;
                      }
  
                      if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
                          // down
                          index++;
                      }
  
                      if (index < 0) {
                          index = 0;
                      }
  
                      items[index].focus();
                  };
  
                  _createClass(Dropdown, null, [{
                      key: "VERSION",
                      get: function get() {
                          return VERSION;
                      }
                  }, {
                      key: "Default",
                      get: function get() {
                          return Default;
                      }
                  }, {
                      key: "DefaultType",
                      get: function get() {
                          return DefaultType;
                      }
                  }]);
  
                  return Dropdown;
              }();
          /**
           * ------------------------------------------------------------------------
           * Data Api implementation
           * ------------------------------------------------------------------------
           */
  
  
          $$$1(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API + " " + Event.KEYUP_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function(event) {
              event.preventDefault();
              event.stopPropagation();
  
              Dropdown._jQueryInterface.call($$$1(this), 'toggle');
          }).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function(e) {
              e.stopPropagation();
          });
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
          $$$1.fn[NAME] = Dropdown._jQueryInterface;
          $$$1.fn[NAME].Constructor = Dropdown;
  
          $$$1.fn[NAME].noConflict = function() {
              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
              return Dropdown._jQueryInterface;
          };
  
          return Dropdown;
      }(jQuery);
  
      var BaseLayout = function($$$1) {
          var ClassName = {
              CANVAS: "bmd-layout-canvas",
              CONTAINER: "bmd-layout-container",
              BACKDROP: "bmd-layout-backdrop"
          };
          var Selector = {
              CANVAS: "." + ClassName.CANVAS,
              CONTAINER: "." + ClassName.CONTAINER,
              BACKDROP: "." + ClassName.BACKDROP
          };
          var Default = {
              canvas: {
                  create: true,
                  required: true,
                  template: "<div class=\"" + ClassName.CANVAS + "\"></div>"
              },
              backdrop: {
                  create: true,
                  required: true,
                  template: "<div class=\"" + ClassName.BACKDROP + "\"></div>"
              }
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var BaseLayout =
              /*#__PURE__*/
              function(_Base) {
                  _inheritsLoose(BaseLayout, _Base);
  
                  function BaseLayout($element, config, properties) {
                      var _this;
  
                      if (properties === void 0) {
                          properties = {};
                      }
  
                      _this = _Base.call(this, $element, $$$1.extend(true, {}, Default, config), properties) || this;
                      _this.$container = _this.findContainer(true);
                      _this.$backdrop = _this.resolveBackdrop();
  
                      _this.resolveCanvas();
  
                      return _this;
                  }
  
                  var _proto = BaseLayout.prototype;
  
                  _proto.dispose = function dispose(dataKey) {
                      _Base.prototype.dispose.call(this, dataKey);
  
                      this.$container = null;
                      this.$backdrop = null;
                  }; // ------------------------------------------------------------------------
                  // protected
                  // Will wrap container in bmd-layout-canvas if necessary
  
  
                  _proto.resolveCanvas = function resolveCanvas() {
                      var bd = this.findCanvas(false);
  
                      if (bd === undefined || bd.length === 0) {
                          if (this.config.canvas.create) {
                              this.$container.wrap(this.config.canvas.template);
                          }
  
                          bd = this.findCanvas(this.config.canvas.required);
                      }
  
                      return bd;
                  }; // Find closest bmd-layout-container based on the given context
  
  
                  _proto.findCanvas = function findCanvas(raiseError, context) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      if (context === void 0) {
                          context = this.$container;
                      }
  
                      var canvas = context.closest(Selector.CANVAS);
  
                      if (canvas.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.CANVAS + " for " + Util$2.describe(context));
                      }
  
                      return canvas;
                  }; // Will add bmd-layout-backdrop to bmd-layout-container if necessary
  
  
                  _proto.resolveBackdrop = function resolveBackdrop() {
                      var bd = this.findBackdrop(false);
  
                      if (bd === undefined || bd.length === 0) {
                          if (this.config.backdrop.create) {
                              this.$container.append(this.config.backdrop.template);
                          }
  
                          bd = this.findBackdrop(this.config.backdrop.required);
                      }
  
                      return bd;
                  }; // Find closest bmd-layout-container based on the given context
  
  
                  _proto.findBackdrop = function findBackdrop(raiseError, context) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      if (context === void 0) {
                          context = this.$container;
                      }
  
                      var backdrop = context.find("> " + Selector.BACKDROP);
  
                      if (backdrop.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.BACKDROP + " for " + Util$2.describe(context));
                      }
  
                      return backdrop;
                  }; // Find closest bmd-layout-container based on the given context
  
  
                  _proto.findContainer = function findContainer(raiseError, context) {
                      if (raiseError === void 0) {
                          raiseError = true;
                      }
  
                      if (context === void 0) {
                          context = this.$element;
                      }
  
                      var container = context.closest(Selector.CONTAINER);
  
                      if (container.length === 0 && raiseError) {
                          $$$1.error("Failed to find " + Selector.CONTAINER + " for " + Util$2.describe(context));
                      }
  
                      return container;
                  }; // ------------------------------------------------------------------------
                  // private
                  // ------------------------------------------------------------------------
                  // static
  
  
                  return BaseLayout;
              }(Base);
  
          return BaseLayout;
      }(jQuery);
  
      var Drawer = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "drawer";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Keycodes = {
              ESCAPE: 27 //ENTER: 13,
              //SPACE: 32
  
          };
          var ClassName = {
              IN: "in",
              DRAWER_IN: "bmd-drawer-in",
              DRAWER_OUT: "bmd-drawer-out",
              DRAWER: "bmd-layout-drawer",
              CONTAINER: "bmd-layout-container"
          };
          var Default = {
              focusSelector: "a, button, input"
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Drawer =
              /*#__PURE__*/
              function(_BaseLayout) {
                  _inheritsLoose(Drawer, _BaseLayout);
  
                  // $element is expected to be the trigger
                  //  i.e. <button class="btn bmd-btn-icon" for="search" data-toggle="drawer" data-target="#my-side-nav-drawer" aria-expanded="false" aria-controls="my-side-nav-drawer">
                  function Drawer($element, config) {
                      var _this;
  
                      _this = _BaseLayout.call(this, $element, $$$1.extend(true, {}, Default, config)) || this;
                      _this.$toggles = $$$1("[data-toggle=\"drawer\"][href=\"#" + _this.$element[0].id + "\"], [data-toggle=\"drawer\"][data-target=\"#" + _this.$element[0].id + "\"]");
  
                      _this._addAria(); // click or escape on the backdrop closes the drawer
  
  
                      _this.$backdrop.keydown(function(ev) {
                          if (ev.which === Keycodes.ESCAPE) {
                              _this.hide();
                          }
                      }).click(function() {
                          _this.hide();
                      }); // escape on the drawer closes it
  
  
                      _this.$element.keydown(function(ev) {
                          if (ev.which === Keycodes.ESCAPE) {
                              _this.hide();
                          }
                      }); // any toggle button clicks
  
  
                      _this.$toggles.click(function() {
                          _this.toggle();
                      });
  
                      return _this;
                  }
  
                  var _proto = Drawer.prototype;
  
                  _proto.dispose = function dispose() {
                      _BaseLayout.prototype.dispose.call(this, DATA_KEY);
  
                      this.$toggles = null;
                  };
  
                  _proto.toggle = function toggle() {
                      if (this._isOpen()) {
                          this.hide();
                      } else {
                          this.show();
                      }
                  };
  
                  _proto.show = function show() {
                      if (this._isForcedClosed() || this._isOpen()) {
                          return;
                      }
  
                      this.$toggles.attr("aria-expanded", true);
                      this.$element.attr("aria-expanded", true);
                      this.$element.attr("aria-hidden", false); // focus on the first focusable item
  
                      var $focusOn = this.$element.find(this.config.focusSelector);
  
                      if ($focusOn.length > 0) {
                          $focusOn.first().focus();
                      }
  
                      this.$container.addClass(ClassName.DRAWER_IN); // backdrop is responsively styled based on bmd-drawer-overlay, therefore style is none of our concern, simply add the marker class and let the scss determine if it should be displayed or not.
  
                      this.$backdrop.addClass(ClassName.IN);
                  };
  
                  _proto.hide = function hide() {
                      if (!this._isOpen()) {
                          return;
                      }
  
                      this.$toggles.attr("aria-expanded", false);
                      this.$element.attr("aria-expanded", false);
                      this.$element.attr("aria-hidden", true);
                      this.$container.removeClass(ClassName.DRAWER_IN);
                      this.$backdrop.removeClass(ClassName.IN);
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  _proto._isOpen = function _isOpen() {
                      return this.$container.hasClass(ClassName.DRAWER_IN);
                  };
  
                  _proto._isForcedClosed = function _isForcedClosed() {
                      return this.$container.hasClass(ClassName.DRAWER_OUT);
                  };
  
                  _proto._addAria = function _addAria() {
                      var isOpen = this._isOpen();
  
                      this.$element.attr("aria-expanded", isOpen);
                      this.$element.attr("aria-hidden", isOpen);
  
                      if (this.$toggles.length) {
                          this.$toggles.attr("aria-expanded", isOpen);
                      }
                  }; // ------------------------------------------------------------------------
                  // static
  
  
                  Drawer._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Drawer($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Drawer;
              }(BaseLayout);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Drawer._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Drawer;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Drawer._jQueryInterface;
          };
  
          return Drawer;
      }(jQuery);
  
      var Ripples = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "ripples";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var ClassName = {
              CONTAINER: "ripple-container",
              DECORATOR: "ripple-decorator"
          };
          var Selector = {
              CONTAINER: "." + ClassName.CONTAINER,
              DECORATOR: "." + ClassName.DECORATOR //,
  
          };
          var Default = {
              container: {
                  template: "<div class='" + ClassName.CONTAINER + "'></div>"
              },
              decorator: {
                  template: "<div class='" + ClassName.DECORATOR + "'></div>"
              },
              trigger: {
                  start: "mousedown touchstart",
                  end: "mouseup mouseleave touchend"
              },
              touchUserAgentRegex: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i,
              duration: 500
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Ripples =
              /*#__PURE__*/
              function() {
                  function Ripples($element, config) {
                      var _this = this;
  
                      this.$element = $element; // console.log(`Adding ripples to ${Util.describe(this.$element)}`)  // eslint-disable-line no-console
  
                      this.config = $$$1.extend(true, {}, Default, config); // attach initial listener
  
                      this.$element.on(this.config.trigger.start, function(event) {
                          _this._onStartRipple(event);
                      });
                  }
  
                  var _proto = Ripples.prototype;
  
                  _proto.dispose = function dispose() {
                      this.$element.data(DATA_KEY, null);
                      this.$element = null;
                      this.$container = null;
                      this.$decorator = null;
                      this.config = null;
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  _proto._onStartRipple = function _onStartRipple(event) {
                      var _this2 = this;
  
                      // Verify if the user is just touching on a device and return if so
                      if (this._isTouch() && event.type === "mousedown") {
                          return;
                      } // Find or create the ripple container element
  
  
                      this._findOrCreateContainer(); // Get relY and relX positions of the container element
  
  
                      var relY = this._getRelY(event);
  
                      var relX = this._getRelX(event); // If relY and/or relX are false, return the event
  
  
                      if (!relY && !relX) {
                          return;
                      } // set the location and color each time (even if element is cached)
  
  
                      this.$decorator.css({
                          left: relX,
                          top: relY,
                          "background-color": this._getRipplesColor()
                      }); // Make sure the ripple has the styles applied (ugly hack but it works)
  
                      this._forceStyleApplication(); // Turn on the ripple animation
  
  
                      this.rippleOn(); // Call the rippleEnd function when the transition 'on' ends
  
                      setTimeout(function() {
                          _this2.rippleEnd();
                      }, this.config.duration); // Detect when the user leaves the element to cleanup if not already done?
  
                      this.$element.on(this.config.trigger.end, function() {
                          if (_this2.$decorator) {
                              // guard against race condition/mouse attack
                              _this2.$decorator.data("mousedown", "off");
  
                              if (_this2.$decorator.data("animating") === "off") {
                                  _this2.rippleOut();
                              }
                          }
                      });
                  };
  
                  _proto._findOrCreateContainer = function _findOrCreateContainer() {
                      if (!this.$container || !this.$container.length > 0) {
                          this.$element.append(this.config.container.template);
                          this.$container = this.$element.find(Selector.CONTAINER);
                      } // always add the rippleElement, it is always removed
  
  
                      this.$container.append(this.config.decorator.template);
                      this.$decorator = this.$container.find(Selector.DECORATOR);
                  }; // Make sure the ripple has the styles applied (ugly hack but it works)
  
  
                  _proto._forceStyleApplication = function _forceStyleApplication() {
                      return window.getComputedStyle(this.$decorator[0]).opacity;
                  };
                  /**
                   * Get the relX
                   */
  
  
                  _proto._getRelX = function _getRelX(event) {
                      var wrapperOffset = this.$container.offset();
                      var result = null;
  
                      if (!this._isTouch()) {
                          // Get the mouse position relative to the ripple wrapper
                          result = event.pageX - wrapperOffset.left;
                      } else {
                          // Make sure the user is using only one finger and then get the touch
                          //  position relative to the ripple wrapper
                          event = event.originalEvent;
  
                          if (event.touches.length === 1) {
                              result = event.touches[0].pageX - wrapperOffset.left;
                          } else {
                              result = false;
                          }
                      }
  
                      return result;
                  };
                  /**
                   * Get the relY
                   */
  
  
                  _proto._getRelY = function _getRelY(event) {
                      var containerOffset = this.$container.offset();
                      var result = null;
  
                      if (!this._isTouch()) {
                          /**
                           * Get the mouse position relative to the ripple wrapper
                           */
                          result = event.pageY - containerOffset.top;
                      } else {
                          /**
                           * Make sure the user is using only one finger and then get the touch
                           * position relative to the ripple wrapper
                           */
                          event = event.originalEvent;
  
                          if (event.touches.length === 1) {
                              result = event.touches[0].pageY - containerOffset.top;
                          } else {
                              result = false;
                          }
                      }
  
                      return result;
                  };
                  /**
                   * Get the ripple color
                   */
  
  
                  _proto._getRipplesColor = function _getRipplesColor() {
                      var color = this.$element.data("ripple-color") ? this.$element.data("ripple-color") : window.getComputedStyle(this.$element[0]).color;
                      return color;
                  };
                  /**
                   * Verify if the client is using a mobile device
                   */
  
  
                  _proto._isTouch = function _isTouch() {
                      return this.config.touchUserAgentRegex.test(navigator.userAgent);
                  };
                  /**
                   * End the animation of the ripple
                   */
  
  
                  _proto.rippleEnd = function rippleEnd() {
                      if (this.$decorator) {
                          // guard against race condition/mouse attack
                          this.$decorator.data("animating", "off");
  
                          if (this.$decorator.data("mousedown") === "off") {
                              this.rippleOut(this.$decorator);
                          }
                      }
                  };
                  /**
                   * Turn off the ripple effect
                   */
  
  
                  _proto.rippleOut = function rippleOut() {
                      var _this3 = this;
  
                      this.$decorator.off();
  
                      if (Util$2.transitionEndSupported()) {
                          this.$decorator.addClass("ripple-out");
                      } else {
                          this.$decorator.animate({
                              opacity: 0
                          }, 100, function() {
                              _this3.$decorator.trigger("transitionend");
                          });
                      }
  
                      this.$decorator.on(Util$2.transitionEndSelector(), function() {
                          if (_this3.$decorator) {
                              _this3.$decorator.remove();
  
                              _this3.$decorator = null;
                          }
                      });
                  };
                  /**
                   * Turn on the ripple effect
                   */
  
  
                  _proto.rippleOn = function rippleOn() {
                      var _this4 = this;
  
                      var size = this._getNewSize();
  
                      if (Util$2.transitionEndSupported()) {
                          this.$decorator.css({
                              "-ms-transform": "scale(" + size + ")",
                              "-moz-transform": "scale(" + size + ")",
                              "-webkit-transform": "scale(" + size + ")",
                              transform: "scale(" + size + ")"
                          }).addClass("ripple-on").data("animating", "on").data("mousedown", "on");
                      } else {
                          this.$decorator.animate({
                              width: Math.max(this.$element.outerWidth(), this.$element.outerHeight()) * 2,
                              height: Math.max(this.$element.outerWidth(), this.$element.outerHeight()) * 2,
                              "margin-left": Math.max(this.$element.outerWidth(), this.$element.outerHeight()) * -1,
                              "margin-top": Math.max(this.$element.outerWidth(), this.$element.outerHeight()) * -1,
                              opacity: 0.2
                          }, this.config.duration, function() {
                              _this4.$decorator.trigger("transitionend");
                          });
                      }
                  };
                  /**
                   * Get the new size based on the element height/width and the ripple width
                   */
  
  
                  _proto._getNewSize = function _getNewSize() {
                      return Math.max(this.$element.outerWidth(), this.$element.outerHeight()) / this.$decorator.outerWidth() * 2.5;
                  }; // ------------------------------------------------------------------------
                  // static
  
  
                  Ripples._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Ripples($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Ripples;
              }();
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Ripples._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Ripples;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Ripples._jQueryInterface;
          };
  
          return Ripples;
      }(jQuery);
  
      var Autofill = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "autofill";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = "bmd" + (NAME.charAt(0).toUpperCase() + NAME.slice(1));
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          var Default = {};
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var Autofill =
              /*#__PURE__*/
              function(_Base) {
                  _inheritsLoose(Autofill, _Base);
  
                  function Autofill($element, config) {
                      var _this;
  
                      _this = _Base.call(this, $element, $$$1.extend(true, {}, Default, config)) || this;
  
                      _this._watchLoading();
  
                      _this._attachEventHandlers();
  
                      return _this;
                  }
  
                  var _proto = Autofill.prototype;
  
                  _proto.dispose = function dispose() {
                      _Base.prototype.dispose.call(this, DATA_KEY);
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  _proto._watchLoading = function _watchLoading() {
                      var _this2 = this;
  
                      // After 10 seconds we are quite sure all the needed inputs are autofilled then we can stop checking them
                      setTimeout(function() {
                          clearInterval(_this2._onLoading);
                      }, 10000);
                  }; // This part of code will detect autofill when the page is loading (username and password inputs for example)
  
  
                  _proto._onLoading = function _onLoading() {
                      setInterval(function() {
                          $$$1("input[type!=checkbox]").each(function(index, element) {
                              var $element = $$$1(element);
  
                              if ($element.val() && $element.val() !== $element.attr("value")) {
                                  $element.trigger("change");
                              }
                          });
                      }, 100);
                  };
  
                  _proto._attachEventHandlers = function _attachEventHandlers() {
                      // Listen on inputs of the focused form
                      //  (because user can select from the autofill dropdown only when the input has focus)
                      var focused = null;
                      $$$1(document).on("focus", "input", function(event) {
                          var $inputs = $$$1(event.currentTarget).closest("form").find("input").not("[type=file]");
                          focused = setInterval(function() {
                              $inputs.each(function(index, element) {
                                  var $element = $$$1(element);
  
                                  if ($element.val() !== $element.attr("value")) {
                                      $element.trigger("change");
                                  }
                              });
                          }, 100);
                      }).on("blur", ".form-group input", function() {
                          clearInterval(focused);
                      });
                  }; // ------------------------------------------------------------------------
                  // static
  
  
                  Autofill._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new Autofill($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return Autofill;
              }(Base);
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = Autofill._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = Autofill;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return Autofill._jQueryInterface;
          };
  
          return Autofill;
      }(jQuery);
  
      /* globals Popper */
      Popper.Defaults.modifiers.computeStyle.gpuAcceleration = false;
      /**
       * $.bootstrapMaterialDesign(config) is a macro class to configure the components generally
       *  used in Material Design for Bootstrap.  You may pass overrides to the configurations
       *  which will be passed into each component, or you may omit use of this class and
       *  configure each component separately.
       */
  
      var BootstrapMaterialDesign = function($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
           */
          var NAME = "bootstrapMaterialDesign";
          var DATA_KEY = "bmd." + NAME;
          var JQUERY_NAME = NAME; // retain this full name since it is long enough not to conflict
  
          var JQUERY_NO_CONFLICT = $$$1.fn[JQUERY_NAME];
          /**
           * Global configuration:
           *  The global configuration hash will be mixed in to each components' config.
           *    e.g. calling $.bootstrapMaterialDesign({global: { validate: true } }) would pass `validate:true` to every component
           *
           *
           * Component configuration:
           *  - selector: may be a string or an array.  Any array will be joined with a comma to generate the selector
           *  - disable any component by defining it as false with an override. e.g. $.bootstrapMaterialDesign({ autofill: false })
           *
           *  @see each individual component for more configuration settings.
           */
  
          var Default = {
              global: {
                  validate: false,
                  label: {
                      className: "bmd-label-static" // default style of label to be used if not specified in the html markup
  
                  }
              },
              autofill: {
                  selector: "body"
              },
              checkbox: {
                  selector: ".checkbox > label > input[type=checkbox]"
              },
              checkboxInline: {
                  selector: "label.checkbox-inline > input[type=checkbox]"
              },
              collapseInline: {
                  selector: '.bmd-collapse-inline [data-toggle="collapse"]'
              },
              drawer: {
                  selector: ".bmd-layout-drawer"
              },
              file: {
                  selector: "input[type=file]"
              },
              radio: {
                  selector: ".radio > label > input[type=radio]"
              },
              radioInline: {
                  selector: "label.radio-inline > input[type=radio]"
              },
              ripples: {
                  //selector: ['.btn:not(.btn-link):not(.ripple-none)'] // testing only
                  selector: [".btn:not(.ripple-none)", ".card-image:not(.ripple-none)", ".navbar a:not(.ripple-none)", ".dropdown-menu a:not(.ripple-none)", ".nav-tabs a:not(.ripple-none)", ".pagination li:not(.active):not(.disabled) a:not(.ripple-none)", ".ripple" // generic marker class to add ripple to elements
                  ]
              },
              select: {
                  selector: ["select"]
              },
              switch: {
                  selector: ".switch > label > input[type=checkbox]"
              },
              text: {
                  // omit inputs we have specialized components to handle - we need to match text, email, etc.  The easiest way to do this appears to be just omit the ones we don't want to match and let the rest fall through to this.
                  selector: ["input:not([type=hidden]):not([type=checkbox]):not([type=radio]):not([type=file]):not([type=button]):not([type=submit]):not([type=reset])"]
              },
              textarea: {
                  selector: ["textarea"]
              },
              arrive: true,
              // create an ordered component list for instantiation
              instantiation: ["ripples", "checkbox", "checkboxInline", "collapseInline", "drawer", //'file',
                  "radio", "radioInline", "switch", "text", "textarea", // "select",
                  "autofill"
              ]
          };
          /**
           * ------------------------------------------------------------------------
           * Class Definition
           * ------------------------------------------------------------------------
           */
  
          var BootstrapMaterialDesign =
              /*#__PURE__*/
              function() {
                  function BootstrapMaterialDesign($element, config) {
                      var _this = this;
  
                      this.$element = $element;
                      this.config = $$$1.extend(true, {}, Default, config);
                      var $document = $$$1(document);
  
                      var _loop = function _loop(component) {
                          // the component's config fragment is passed in directly, allowing users to override
                          var componentConfig = _this.config[component]; // check to make sure component config is enabled (not `false`)
  
                          if (componentConfig) {
                              // assemble the selector as it may be an array
                              var selector = _this._resolveSelector(componentConfig); // mix in global options
  
  
                              componentConfig = $$$1.extend(true, {}, _this.config.global, componentConfig); // create the jquery fn name e.g. 'bmdText' for 'text'
  
                              var componentName = "" + (component.charAt(0).toUpperCase() + component.slice(1));
                              var jqueryFn = "bmd" + componentName;
  
                              try {
                                  // safely instantiate component on selector elements with config, report errors and move on.
                                  // console.debug(`instantiating: $('${selector}')[${jqueryFn}](${componentConfig})`) // eslint-disable-line no-console
                                  $$$1(selector)[jqueryFn](componentConfig); // add to arrive if present and enabled
  
                                  if (document.arrive && _this.config.arrive) {
                                      $document.arrive(selector, function() {
                                          // eslint-disable-line no-loop-func
                                          $$$1(this)[jqueryFn](componentConfig);
                                      });
                                  }
                              } catch (e) {
                                  var message = "Failed to instantiate component: $('" + selector + "')[" + jqueryFn + "](" + componentConfig + ")";
                                  console.error(message, e, "\nSelected elements: ", $$$1(selector)); // eslint-disable-line no-console
  
                                  throw e;
                              }
                          }
                      };
  
                      for (var _iterator = this.config.instantiation, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                          var _ref;
  
                          if (_isArray) {
                              if (_i >= _iterator.length) break;
                              _ref = _iterator[_i++];
                          } else {
                              _i = _iterator.next();
                              if (_i.done) break;
                              _ref = _i.value;
                          }
  
                          var component = _ref;
  
                          _loop(component);
                      }
                  }
  
                  var _proto = BootstrapMaterialDesign.prototype;
  
                  _proto.dispose = function dispose() {
                      this.$element.data(DATA_KEY, null);
                      this.$element = null;
                      this.config = null;
                  }; // ------------------------------------------------------------------------
                  // private
  
  
                  _proto._resolveSelector = function _resolveSelector(componentConfig) {
                      var selector = componentConfig.selector;
  
                      if (Array.isArray(selector)) {
                          selector = selector.join(", ");
                      }
  
                      return selector;
                  }; // ------------------------------------------------------------------------
                  // static
  
  
                  BootstrapMaterialDesign._jQueryInterface = function _jQueryInterface(config) {
                      return this.each(function() {
                          var $element = $$$1(this);
                          var data = $element.data(DATA_KEY);
  
                          if (!data) {
                              data = new BootstrapMaterialDesign($element, config);
                              $element.data(DATA_KEY, data);
                          }
                      });
                  };
  
                  return BootstrapMaterialDesign;
              }();
          /**
           * ------------------------------------------------------------------------
           * jQuery
           * ------------------------------------------------------------------------
           */
  
  
          $$$1.fn[JQUERY_NAME] = BootstrapMaterialDesign._jQueryInterface;
          $$$1.fn[JQUERY_NAME].Constructor = BootstrapMaterialDesign;
  
          $$$1.fn[JQUERY_NAME].noConflict = function() {
              $$$1.fn[JQUERY_NAME] = JQUERY_NO_CONFLICT;
              return BootstrapMaterialDesign._jQueryInterface;
          };
  
          return BootstrapMaterialDesign;
      }(jQuery);
  
      /*
       * This is the main entry point.
       *
       * You can import other modules here, including external packages. When bundling using rollup you can mark those modules as external and have them excluded or, if they have a jsnext:main entry in their package.json (like this package does), let rollup bundle them into your dist file.
       *
       * at your application entry point.  This is necessary for browsers that do not yet support some ES2015 runtime necessities such as Symbol.  We do this in `index-iife.js` for our iife rollup bundle.
       */
      // Bootstrap components
  
  })));
  //# sourceMappingURL=bootstrap-material-design.js.map
  /*! =========================================================
   *
   * Material Kit PRO - v2.0.2 (Bootstrap 4.0.0 Final Edition)
   *
   * =========================================================
   *
   * Product Page: https://www.creative-tim.com/product/material-kit-pro
   * Available with purchase of license from http://www.creative-tim.com/product/material-kit-pro
   * Copyright 2017 Creative Tim (https://www.creative-tim.com)
   * License Creative Tim (https://www.creative-tim.com/license)
   *
   * ========================================================= */
  
  var big_image;
  
  $(document).ready(function() {
      BrowserDetect.init();
  
      // Init Material scripts for buttons ripples, inputs animations etc, more info on the next link https://github.com/FezVrasta/bootstrap-material-design#materialjs
      $('body').bootstrapMaterialDesign();
  
      window_width = $(window).width();
  
      $navbar = $('.navbar[color-on-scroll]');
      scroll_distance = $navbar.attr('color-on-scroll') || 500;
  
      $navbar_collapse = $('.navbar').find('.navbar-collapse');
  
      //  Activate the Tooltips
      $('[data-toggle="tooltip"], [rel="tooltip"]').tooltip();
  
  
      // FileInput
      $('.form-file-simple .inputFileVisible').click(function() {
          $(this).siblings('.inputFileHidden').trigger('click');
      });
  
      $('.form-file-simple .inputFileHidden').change(function() {
          var filename = $(this).val().replace(/C:\\fakepath\\/i, '');
          $(this).siblings('.inputFileVisible').val(filename);
      });
  
      $('.form-file-multiple .inputFileVisible, .form-file-multiple .input-group-btn').click(function() {
          $(this).parent().parent().find('.inputFileHidden').trigger('click');
          $(this).parent().parent().addClass('is-focused');
      });
  
      $('.form-file-multiple .inputFileHidden').change(function() {
          var names = '';
          for (var i = 0; i < $(this).get(0).files.length; ++i) {
              if (i < $(this).get(0).files.length - 1) {
                  names += $(this).get(0).files.item(i).name + ',';
              } else {
                  names += $(this).get(0).files.item(i).name;
              }
          }
          $(this).siblings('.input-group').find('.inputFileVisible').val(names);
      });
  
      $('.form-file-multiple .btn').on('focus', function() {
          $(this).parent().siblings().trigger('focus');
      });
  
      $('.form-file-multiple .btn').on('focusout', function() {
          $(this).parent().siblings().trigger('focusout');
      });
  
      //    Activate bootstrap-select
      if ($(".selectpicker").length != 0) {
          $(".selectpicker").selectpicker();
      }
  
      // Activate Popovers
      $('[data-toggle="popover"]').popover();
  
      // Active Carousel
      $('.carousel').carousel({
          interval: 3000
      });
  
      //Activate tags
      // we style the badges with our colors
      var tagClass = $('.tagsinput').data('color');
  
      if ($(".tagsinput").length != 0) {
          $('.tagsinput').tagsinput();
      }
  
      $('.bootstrap-tagsinput').addClass('' + tagClass + '-badge');
  
      if ($('.navbar-color-on-scroll').length != 0) {
          $(window).on('scroll', materialKit.checkScrollForTransparentNavbar);
      }
  
      materialKit.checkScrollForTransparentNavbar();
  
      if (window_width >= 768) {
          big_image = $('.page-header[data-parallax="true"]');
          if (big_image.length != 0) {
              $(window).on('scroll', materialKit.checkScrollForParallax);
          }
  
      }
  });
  
  $(window).on("load", function() {
      //initialise rotating cards
      materialKit.initRotateCard();
  
      //initialise colored shadow
      materialKit.initColoredShadows();
  });
  
  $(document).on('click', '.card-rotate .btn-rotate', function() {
      var $rotating_card_container = $(this).closest('.rotating-card-container');
  
      if ($rotating_card_container.hasClass('hover')) {
          $rotating_card_container.removeClass('hover');
      } else {
          $rotating_card_container.addClass('hover');
      }
  });
  
  $(document).on('click', '.navbar-toggler', function() {
      $toggle = $(this);
  
      if (materialKit.misc.navbar_menu_visible == 1) {
          $('html').removeClass('nav-open');
          materialKit.misc.navbar_menu_visible = 0;
          $('#bodyClick').remove();
          setTimeout(function() {
              $toggle.removeClass('toggled');
          }, 550);
  
          $('html').removeClass('nav-open-absolute');
      } else {
          setTimeout(function() {
              $toggle.addClass('toggled');
          }, 580);
  
  
          div = '<div id="bodyClick"></div>';
          $(div).appendTo("body").click(function() {
              $('html').removeClass('nav-open');
  
              if ($('nav').hasClass('navbar-absolute')) {
                  $('html').removeClass('nav-open-absolute');
              }
              materialKit.misc.navbar_menu_visible = 0;
              $('#bodyClick').remove();
              setTimeout(function() {
                  $toggle.removeClass('toggled');
              }, 550);
          });
  
          if ($('nav').hasClass('navbar-absolute')) {
              $('html').addClass('nav-open-absolute');
          }
  
          $('html').addClass('nav-open');
          materialKit.misc.navbar_menu_visible = 1;
      }
  });
  
  $(window).on('resize', function() {
      materialKit.initRotateCard();
  });
  
  materialKit = {
      misc: {
          navbar_menu_visible: 0,
          window_width: 0,
          transparent: true,
          colored_shadows: true,
          fixedTop: false,
          navbar_initialized: false,
          isWindow: document.documentMode || /Edge/.test(navigator.userAgent)
      },
  
      checkScrollForParallax: function() {
          oVal = ($(window).scrollTop() / 3);
          big_image.css({
              'transform': 'translate3d(0,' + oVal + 'px,0)',
              '-webkit-transform': 'translate3d(0,' + oVal + 'px,0)',
              '-ms-transform': 'translate3d(0,' + oVal + 'px,0)',
              '-o-transform': 'translate3d(0,' + oVal + 'px,0)'
          });
      },
  
      initFormExtendedDatetimepickers: function() {
          $('.datetimepicker').datetimepicker({
              icons: {
                  time: "fa fa-clock-o",
                  date: "fa fa-calendar",
                  up: "fa fa-chevron-up",
                  down: "fa fa-chevron-down",
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
              }
          });
  
          $('.datepicker').datetimepicker({
              format: 'MM/DD/YYYY',
              icons: {
                  time: "fa fa-clock-o",
                  date: "fa fa-calendar",
                  up: "fa fa-chevron-up",
                  down: "fa fa-chevron-down",
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
              }
          });
  
          $('.timepicker').datetimepicker({
              //          format: 'H:mm',    // use this format if you want the 24hours timepicker
              format: 'h:mm A', //use this format if you want the 12hours timpiecker with AM/PM toggle
              icons: {
                  time: "fa fa-clock-o",
                  date: "fa fa-calendar",
                  up: "fa fa-chevron-up",
                  down: "fa fa-chevron-down",
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
  
              }
          });
      },
  
  
      initSliders: function() {
          // Sliders for demo purpose
          var slider = document.getElementById('sliderRegular');
  
          noUiSlider.create(slider, {
              start: 40,
              connect: [true, false],
              range: {
                  min: 0,
                  max: 100
              }
          });
  
          var slider2 = document.getElementById('sliderDouble');
  
          noUiSlider.create(slider2, {
              start: [20, 60],
              connect: true,
              range: {
                  min: 0,
                  max: 100
              }
          });
      },
  
  
      initColoredShadows: function() {
          if (materialKit.misc.colored_shadows == true) {
              if (!(BrowserDetect.browser == 'Explorer' && BrowserDetect.version <= 12)) {
                  $('.card:not([data-colored-shadow="false"]) .card-header-image').each(function() {
                      $card_img = $(this);
  
                      is_on_dark_screen = $(this).closest('.section-dark, .section-image').length;
  
                      // we block the generator of the colored shadows on dark sections, because they are not natural
                      if (is_on_dark_screen == 0) {
                          var img_source = $card_img.find('img').attr('src');
                          var is_rotating = $card_img.closest('.card-rotate').length == 1 ? true : false;
                          var $append_div = $card_img;
  
                          var colored_shadow_div = $('<div class="colored-shadow"/>');
  
                          if (is_rotating) {
                              var card_image_height = $card_img.height();
                              var card_image_width = $card_img.width();
  
                              $(this).find('.back').css({
                                  'height': card_image_height + 'px',
                                  'width': card_image_width + 'px'
                              });
                              $append_div = $card_img.find('.front');
                          }
  
                          colored_shadow_div.css({
                              'background-image': 'url(' + img_source + ')'
                          }).appendTo($append_div);
  
                          if ($card_img.width() > 700) {
                              colored_shadow_div.addClass('colored-shadow-big');
                          }
  
                          setTimeout(function() {
                              colored_shadow_div.css('opacity', 1);
                          }, 200);
                      }
  
                  });
              }
          }
      },
  
      initRotateCard: debounce(function() {
          $('.rotating-card-container .card-rotate').each(function() {
              var $this = $(this);
  
              var card_width = $(this).parent().width();
              var card_height = $(this).find('.front .card-body').outerHeight();
  
              $this.parent().css({
                  'height': card_height + 'px',
                  'margin-bottom': 30 + 'px'
              });
  
              $this.find('.front').css({
                  'height': card_height + 35 + 'px',
                  'width': card_width + 'px',
              });
  
              $this.find('.back').css({
                  'height': card_height + 35 + 'px',
                  'width': card_width + 'px',
              });
          });
      }, 50),
  
      checkScrollForTransparentNavbar: debounce(function() {
          if ($(document).scrollTop() > scroll_distance) {
              if (materialKit.misc.transparent) {
                  materialKit.misc.transparent = false;
                  $('.navbar-color-on-scroll').removeClass('navbar-transparent');
              }
          } else {
              if (!materialKit.misc.transparent) {
                  materialKit.misc.transparent = true;
                  $('.navbar-color-on-scroll').addClass('navbar-transparent');
              }
          }
      }, 17)
  };
  // Returns a function, that, as long as it continues to be invoked, will not
  // be triggered. The function will be called after it stops being called for
  // N milliseconds. If `immediate` is passed, trigger the function on the
  // leading edge, instead of the trailing.
  
  function debounce(func, wait, immediate) {
      var timeout;
      return function() {
          var context = this,
              args = arguments;
          clearTimeout(timeout);
          timeout = setTimeout(function() {
              timeout = null;
              if (!immediate) func.apply(context, args);
          }, wait);
          if (immediate && !timeout) func.apply(context, args);
      };
  }
  
  var BrowserDetect = {
      init: function() {
          this.browser = this.searchString(this.dataBrowser) || "Other";
          this.version = this.searchVersion(navigator.userAgent) || this.searchVersion(navigator.appVersion) || "Unknown";
      },
      searchString: function(data) {
          for (var i = 0; i < data.length; i++) {
              var dataString = data[i].string;
              this.versionSearchString = data[i].subString;
  
              if (dataString.indexOf(data[i].subString) !== -1) {
                  return data[i].identity;
              }
          }
      },
      searchVersion: function(dataString) {
          var index = dataString.indexOf(this.versionSearchString);
          if (index === -1) {
              return;
          }
  
          var rv = dataString.indexOf("rv:");
          if (this.versionSearchString === "Trident" && rv !== -1) {
              return parseFloat(dataString.substring(rv + 3));
          } else {
              return parseFloat(dataString.substring(index + this.versionSearchString.length + 1));
          }
      },
  
      dataBrowser: [{
              string: navigator.userAgent,
              subString: "Chrome",
              identity: "Chrome"
          },
          {
              string: navigator.userAgent,
              subString: "MSIE",
              identity: "Explorer"
          },
          {
              string: navigator.userAgent,
              subString: "Trident",
              identity: "Explorer"
          },
          {
              string: navigator.userAgent,
              subString: "Firefox",
              identity: "Firefox"
          },
          {
              string: navigator.userAgent,
              subString: "Safari",
              identity: "Safari"
          },
          {
              string: navigator.userAgent,
              subString: "Opera",
              identity: "Opera"
          }
      ]
  
  };
  
  var better_browser = '<div class="container"><div class="better-browser row"><div class="col-md-2"></div><div class="col-md-8"><h3>We are sorry but it looks like your Browser doesn\'t support our website Features. In order to get the full experience please download a new version of your favourite browser.</h3></div><div class="col-md-2"></div><br><div class="col-md-4"><a href="https://www.mozilla.org/ro/firefox/new/" class="btn btn-warning">Mozilla</a><br></div><div class="col-md-4"><a href="https://www.google.com/chrome/browser/desktop/index.html" class="btn ">Chrome</a><br></div><div class="col-md-4"><a href="http://windows.microsoft.com/en-us/internet-explorer/ie-11-worldwide-languages" class="btn">Internet Explorer</a><br></div><br><br><h4>Thank you!</h4></div></div>';
  var big_image;
  $(document).ready(function() {
      BrowserDetect.init(), $('body').bootstrapMaterialDesign(), window_width = $(window).width(), $navbar = $('.navbar[color-on-scroll]'), scroll_distance = $navbar.attr('color-on-scroll') || 500, $navbar_collapse = $('.navbar').find('.navbar-collapse'), $('[data-toggle="tooltip"], [rel="tooltip"]').tooltip(), $('.form-file-simple .inputFileVisible').click(function() {
          $(this).siblings('.inputFileHidden').trigger('click')
      }), $('.form-file-simple .inputFileHidden').change(function() {
          var a = $(this).val().replace(/C:\\fakepath\\/i, '');
          $(this).siblings('.inputFileVisible').val(a)
      }), $('.form-file-multiple .inputFileVisible, .form-file-multiple .input-group-btn').click(function() {
          $(this).parent().parent().find('.inputFileHidden').trigger('click'), $(this).parent().parent().addClass('is-focused')
      }), $('.form-file-multiple .inputFileHidden').change(function() {
          for (var a = '', b = 0; b < $(this).get(0).files.length; ++b) a += b < $(this).get(0).files.length - 1 ? $(this).get(0).files.item(b).name + ',' : $(this).get(0).files.item(b).name;
          $(this).siblings('.input-group').find('.inputFileVisible').val(a)
      }), $('.form-file-multiple .btn').on('focus', function() {
          $(this).parent().siblings().trigger('focus')
      }), $('.form-file-multiple .btn').on('focusout', function() {
          $(this).parent().siblings().trigger('focusout')
      }), 0 != $('.selectpicker').length && $('.selectpicker').selectpicker(), $('[data-toggle="popover"]').popover(), $('.carousel').carousel({
          interval: 3e3
      });
      var a = $('.tagsinput').data('color');
      0 != $('.tagsinput').length && $('.tagsinput').tagsinput(), $('.bootstrap-tagsinput').addClass('' + a + '-badge'), 0 != $('.navbar-color-on-scroll').length && $(window).on('scroll', materialKit.checkScrollForTransparentNavbar), materialKit.checkScrollForTransparentNavbar(), 768 <= window_width && (big_image = $('.page-header[data-parallax="true"]'), 0 != big_image.length && $(window).on('scroll', materialKit.checkScrollForParallax))
  }), $(window).on('load', function() {
      materialKit.initRotateCard(), materialKit.initColoredShadows()
  }), $(document).on('click', '.card-rotate .btn-rotate', function() {
      var a = $(this).closest('.rotating-card-container');
      a.hasClass('hover') ? a.removeClass('hover') : a.addClass('hover')
  }), $(document).on('click', '.navbar-toggler', function() {
      $toggle = $(this), 1 == materialKit.misc.navbar_menu_visible ? ($('html').removeClass('nav-open'), materialKit.misc.navbar_menu_visible = 0, $('#bodyClick').remove(), setTimeout(function() {
          $toggle.removeClass('toggled')
      }, 550), $('html').removeClass('nav-open-absolute')) : (setTimeout(function() {
          $toggle.addClass('toggled')
      }, 580), div = '<div id="bodyClick"></div>', $(div).appendTo('body').click(function() {
          $('html').removeClass('nav-open'), $('nav').hasClass('navbar-absolute') && $('html').removeClass('nav-open-absolute'), materialKit.misc.navbar_menu_visible = 0, $('#bodyClick').remove(), setTimeout(function() {
              $toggle.removeClass('toggled')
          }, 550)
      }), $('nav').hasClass('navbar-absolute') && $('html').addClass('nav-open-absolute'), $('html').addClass('nav-open'), materialKit.misc.navbar_menu_visible = 1)
  }), $(window).on('resize', function() {
      materialKit.initRotateCard()
  }), materialKit = {
      misc: {
          navbar_menu_visible: 0,
          window_width: 0,
          transparent: !0,
          colored_shadows: !0,
          fixedTop: !1,
          navbar_initialized: !1,
          isWindow: document.documentMode || /Edge/.test(navigator.userAgent)
      },
      checkScrollForParallax: function() {
          oVal = $(window).scrollTop() / 3, big_image.css({
              transform: 'translate3d(0,' + oVal + 'px,0)',
              "-webkit-transform": 'translate3d(0,' + oVal + 'px,0)',
              "-ms-transform": 'translate3d(0,' + oVal + 'px,0)',
              "-o-transform": 'translate3d(0,' + oVal + 'px,0)'
          })
      },
      initFormExtendedDatetimepickers: function() {
          $('.datetimepicker').datetimepicker({
              icons: {
                  time: 'fa fa-clock-o',
                  date: 'fa fa-calendar',
                  up: 'fa fa-chevron-up',
                  down: 'fa fa-chevron-down',
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
              }
          }), $('.datepicker').datetimepicker({
              format: 'MM/DD/YYYY',
              icons: {
                  time: 'fa fa-clock-o',
                  date: 'fa fa-calendar',
                  up: 'fa fa-chevron-up',
                  down: 'fa fa-chevron-down',
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
              }
          }), $('.timepicker').datetimepicker({
              format: 'h:mm A',
              icons: {
                  time: 'fa fa-clock-o',
                  date: 'fa fa-calendar',
                  up: 'fa fa-chevron-up',
                  down: 'fa fa-chevron-down',
                  previous: 'fa fa-chevron-left',
                  next: 'fa fa-chevron-right',
                  today: 'fa fa-screenshot',
                  clear: 'fa fa-trash',
                  close: 'fa fa-remove'
              }
          })
      },
      initSliders: function() {
          var a = document.getElementById('sliderRegular');
          noUiSlider.create(a, {
              start: 40,
              connect: [!0, !1],
              range: {
                  min: 0,
                  max: 100
              }
          });
          var b = document.getElementById('sliderDouble');
          noUiSlider.create(b, {
              start: [20, 60],
              connect: !0,
              range: {
                  min: 0,
                  max: 100
              }
          })
      },
      initColoredShadows: function() {
          !0 != materialKit.misc.colored_shadows || 'Explorer' == BrowserDetect.browser && 12 >= BrowserDetect.version || $('.card:not([data-colored-shadow="false"]) .card-header-image').each(function() {
              if ($card_img = $(this), is_on_dark_screen = $(this).closest('.section-dark, .section-image').length, 0 == is_on_dark_screen) {
                  var a = $card_img.find('img').attr('src'),
                      b = 1 == $card_img.closest('.card-rotate').length,
                      c = $card_img,
                      d = $('<div class="colored-shadow"/>');
                  if (b) {
                      var e = $card_img.height(),
                          f = $card_img.width();
                      $(this).find('.back').css({
                          height: e + 'px',
                          width: f + 'px'
                      }), c = $card_img.find('.front')
                  }
                  d.css({
                      "background-image": 'url(' + a + ')'
                  }).appendTo(c), 700 < $card_img.width() && d.addClass('colored-shadow-big'), setTimeout(function() {
                      d.css('opacity', 1)
                  }, 200)
              }
          })
      },
      initRotateCard: debounce(function() {
          $('.rotating-card-container .card-rotate').each(function() {
              var a = $(this),
                  b = $(this).parent().width(),
                  c = $(this).find('.front .card-body').outerHeight();
              a.parent().css({
                  height: c + 'px',
                  "margin-bottom": '30px'
              }), a.find('.front').css({
                  height: c + 35 + 'px',
                  width: b + 'px'
              }), a.find('.back').css({
                  height: c + 35 + 'px',
                  width: b + 'px'
              })
          })
      }, 50),
      checkScrollForTransparentNavbar: debounce(function() {
          $(document).scrollTop() > scroll_distance ? materialKit.misc.transparent && (materialKit.misc.transparent = !1, $('.navbar-color-on-scroll').removeClass('navbar-transparent')) : !materialKit.misc.transparent && (materialKit.misc.transparent = !0, $('.navbar-color-on-scroll').addClass('navbar-transparent'))
      }, 17)
  };
  
  function debounce(a, b, c) {
      var d;
      return function() {
          var e = this,
              f = arguments;
          clearTimeout(d), d = setTimeout(function() {
              d = null, c || a.apply(e, f)
          }, b), c && !d && a.apply(e, f)
      }
  }
  var BrowserDetect = {
          init: function() {
              this.browser = this.searchString(this.dataBrowser) || 'Other', this.version = this.searchVersion(navigator.userAgent) || this.searchVersion(navigator.appVersion) || 'Unknown'
          },
          searchString: function(a) {
              for (var b, c = 0; c < a.length; c++)
                  if (b = a[c].string, this.versionSearchString = a[c].subString, -1 !== b.indexOf(a[c].subString)) return a[c].identity
          },
          searchVersion: function(a) {
              var b = a.indexOf(this.versionSearchString);
              if (-1 !== b) {
                  var c = a.indexOf('rv:');
                  return 'Trident' === this.versionSearchString && -1 !== c ? parseFloat(a.substring(c + 3)) : parseFloat(a.substring(b + this.versionSearchString.length + 1))
              }
          },
          dataBrowser: [{
              string: navigator.userAgent,
              subString: 'Chrome',
              identity: 'Chrome'
          }, {
              string: navigator.userAgent,
              subString: 'MSIE',
              identity: 'Explorer'
          }, {
              string: navigator.userAgent,
              subString: 'Trident',
              identity: 'Explorer'
          }, {
              string: navigator.userAgent,
              subString: 'Firefox',
              identity: 'Firefox'
          }, {
              string: navigator.userAgent,
              subString: 'Safari',
              identity: 'Safari'
          }, {
              string: navigator.userAgent,
              subString: 'Opera',
              identity: 'Opera'
          }]
      },
      better_browser = '<div class="container"><div class="better-browser row"><div class="col-md-2"></div><div class="col-md-8"><h3>We are sorry but it looks like your Browser doesn\'t support our website Features. In order to get the full experience please download a new version of your favourite browser.</h3></div><div class="col-md-2"></div><br><div class="col-md-4"><a href="https://www.mozilla.org/ro/firefox/new/" class="btn btn-warning">Mozilla</a><br></div><div class="col-md-4"><a href="https://www.google.com/chrome/browser/desktop/index.html" class="btn ">Chrome</a><br></div><div class="col-md-4"><a href="http://windows.microsoft.com/en-us/internet-explorer/ie-11-worldwide-languages" class="btn">Internet Explorer</a><br></div><br><br><h4>Thank you!</h4></div></div>';
  /*! jQuery v3.2.1 | (c) JS Foundation and other contributors | jquery.org/license */ ! function(a, b) {
      "use strict";
      "object" == typeof module && "object" == typeof module.exports ? module.exports = a.document ? b(a, !0) : function(a) {
          if (!a.document) throw new Error("jQuery requires a window with a document");
          return b(a)
      } : b(a)
  }("undefined" != typeof window ? window : this, function(a, b) {
      "use strict";
      var c = [],
          d = a.document,
          e = Object.getPrototypeOf,
          f = c.slice,
          g = c.concat,
          h = c.push,
          i = c.indexOf,
          j = {},
          k = j.toString,
          l = j.hasOwnProperty,
          m = l.toString,
          n = m.call(Object),
          o = {};
  
      function p(a, b) {
          b = b || d;
          var c = b.createElement("script");
          c.text = a, b.head.appendChild(c).parentNode.removeChild(c)
      }
      var q = "3.2.1",
          r = function(a, b) {
              return new r.fn.init(a, b)
          },
          s = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
          t = /^-ms-/,
          u = /-([a-z])/g,
          v = function(a, b) {
              return b.toUpperCase()
          };
      r.fn = r.prototype = {
          jquery: q,
          constructor: r,
          length: 0,
          toArray: function() {
              return f.call(this)
          },
          get: function(a) {
              return null == a ? f.call(this) : a < 0 ? this[a + this.length] : this[a]
          },
          pushStack: function(a) {
              var b = r.merge(this.constructor(), a);
              return b.prevObject = this, b
          },
          each: function(a) {
              return r.each(this, a)
          },
          map: function(a) {
              return this.pushStack(r.map(this, function(b, c) {
                  return a.call(b, c, b)
              }))
          },
          slice: function() {
              return this.pushStack(f.apply(this, arguments))
          },
          first: function() {
              return this.eq(0)
          },
          last: function() {
              return this.eq(-1)
          },
          eq: function(a) {
              var b = this.length,
                  c = +a + (a < 0 ? b : 0);
              return this.pushStack(c >= 0 && c < b ? [this[c]] : [])
          },
          end: function() {
              return this.prevObject || this.constructor()
          },
          push: h,
          sort: c.sort,
          splice: c.splice
      }, r.extend = r.fn.extend = function() {
          var a, b, c, d, e, f, g = arguments[0] || {},
              h = 1,
              i = arguments.length,
              j = !1;
          for ("boolean" == typeof g && (j = g, g = arguments[h] || {}, h++), "object" == typeof g || r.isFunction(g) || (g = {}), h === i && (g = this, h--); h < i; h++)
              if (null != (a = arguments[h]))
                  for (b in a) c = g[b], d = a[b], g !== d && (j && d && (r.isPlainObject(d) || (e = Array.isArray(d))) ? (e ? (e = !1, f = c && Array.isArray(c) ? c : []) : f = c && r.isPlainObject(c) ? c : {}, g[b] = r.extend(j, f, d)) : void 0 !== d && (g[b] = d));
          return g
      }, r.extend({
          expando: "jQuery" + (q + Math.random()).replace(/\D/g, ""),
          isReady: !0,
          error: function(a) {
              throw new Error(a)
          },
          noop: function() {},
          isFunction: function(a) {
              return "function" === r.type(a)
          },
          isWindow: function(a) {
              return null != a && a === a.window
          },
          isNumeric: function(a) {
              var b = r.type(a);
              return ("number" === b || "string" === b) && !isNaN(a - parseFloat(a))
          },
          isPlainObject: function(a) {
              var b, c;
              return !(!a || "[object Object]" !== k.call(a)) && (!(b = e(a)) || (c = l.call(b, "constructor") && b.constructor, "function" == typeof c && m.call(c) === n))
          },
          isEmptyObject: function(a) {
              var b;
              for (b in a) return !1;
              return !0
          },
          type: function(a) {
              return null == a ? a + "" : "object" == typeof a || "function" == typeof a ? j[k.call(a)] || "object" : typeof a
          },
          globalEval: function(a) {
              p(a)
          },
          camelCase: function(a) {
              return a.replace(t, "ms-").replace(u, v)
          },
          each: function(a, b) {
              var c, d = 0;
              if (w(a)) {
                  for (c = a.length; d < c; d++)
                      if (b.call(a[d], d, a[d]) === !1) break
              } else
                  for (d in a)
                      if (b.call(a[d], d, a[d]) === !1) break;
              return a
          },
          trim: function(a) {
              return null == a ? "" : (a + "").replace(s, "")
          },
          makeArray: function(a, b) {
              var c = b || [];
              return null != a && (w(Object(a)) ? r.merge(c, "string" == typeof a ? [a] : a) : h.call(c, a)), c
          },
          inArray: function(a, b, c) {
              return null == b ? -1 : i.call(b, a, c)
          },
          merge: function(a, b) {
              for (var c = +b.length, d = 0, e = a.length; d < c; d++) a[e++] = b[d];
              return a.length = e, a
          },
          grep: function(a, b, c) {
              for (var d, e = [], f = 0, g = a.length, h = !c; f < g; f++) d = !b(a[f], f), d !== h && e.push(a[f]);
              return e
          },
          map: function(a, b, c) {
              var d, e, f = 0,
                  h = [];
              if (w(a))
                  for (d = a.length; f < d; f++) e = b(a[f], f, c), null != e && h.push(e);
              else
                  for (f in a) e = b(a[f], f, c), null != e && h.push(e);
              return g.apply([], h)
          },
          guid: 1,
          proxy: function(a, b) {
              var c, d, e;
              if ("string" == typeof b && (c = a[b], b = a, a = c), r.isFunction(a)) return d = f.call(arguments, 2), e = function() {
                  return a.apply(b || this, d.concat(f.call(arguments)))
              }, e.guid = a.guid = a.guid || r.guid++, e
          },
          now: Date.now,
          support: o
      }), "function" == typeof Symbol && (r.fn[Symbol.iterator] = c[Symbol.iterator]), r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(a, b) {
          j["[object " + b + "]"] = b.toLowerCase()
      });
  
      function w(a) {
          var b = !!a && "length" in a && a.length,
              c = r.type(a);
          return "function" !== c && !r.isWindow(a) && ("array" === c || 0 === b || "number" == typeof b && b > 0 && b - 1 in a)
      }
      var x = function(a) {
          var b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u = "sizzle" + 1 * new Date,
              v = a.document,
              w = 0,
              x = 0,
              y = ha(),
              z = ha(),
              A = ha(),
              B = function(a, b) {
                  return a === b && (l = !0), 0
              },
              C = {}.hasOwnProperty,
              D = [],
              E = D.pop,
              F = D.push,
              G = D.push,
              H = D.slice,
              I = function(a, b) {
                  for (var c = 0, d = a.length; c < d; c++)
                      if (a[c] === b) return c;
                  return -1
              },
              J = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
              K = "[\\x20\\t\\r\\n\\f]",
              L = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
              M = "\\[" + K + "*(" + L + ")(?:" + K + "*([*^$|!~]?=)" + K + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + L + "))|)" + K + "*\\]",
              N = ":(" + L + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + M + ")*)|.*)\\)|)",
              O = new RegExp(K + "+", "g"),
              P = new RegExp("^" + K + "+|((?:^|[^\\\\])(?:\\\\.)*)" + K + "+$", "g"),
              Q = new RegExp("^" + K + "*," + K + "*"),
              R = new RegExp("^" + K + "*([>+~]|" + K + ")" + K + "*"),
              S = new RegExp("=" + K + "*([^\\]'\"]*?)" + K + "*\\]", "g"),
              T = new RegExp(N),
              U = new RegExp("^" + L + "$"),
              V = {
                  ID: new RegExp("^#(" + L + ")"),
                  CLASS: new RegExp("^\\.(" + L + ")"),
                  TAG: new RegExp("^(" + L + "|[*])"),
                  ATTR: new RegExp("^" + M),
                  PSEUDO: new RegExp("^" + N),
                  CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + K + "*(even|odd|(([+-]|)(\\d*)n|)" + K + "*(?:([+-]|)" + K + "*(\\d+)|))" + K + "*\\)|)", "i"),
                  bool: new RegExp("^(?:" + J + ")$", "i"),
                  needsContext: new RegExp("^" + K + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + K + "*((?:-\\d)?\\d*)" + K + "*\\)|)(?=[^-]|$)", "i")
              },
              W = /^(?:input|select|textarea|button)$/i,
              X = /^h\d$/i,
              Y = /^[^{]+\{\s*\[native \w/,
              Z = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
              $ = /[+~]/,
              _ = new RegExp("\\\\([\\da-f]{1,6}" + K + "?|(" + K + ")|.)", "ig"),
              aa = function(a, b, c) {
                  var d = "0x" + b - 65536;
                  return d !== d || c ? b : d < 0 ? String.fromCharCode(d + 65536) : String.fromCharCode(d >> 10 | 55296, 1023 & d | 56320)
              },
              ba = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
              ca = function(a, b) {
                  return b ? "\0" === a ? "\ufffd" : a.slice(0, -1) + "\\" + a.charCodeAt(a.length - 1).toString(16) + " " : "\\" + a
              },
              da = function() {
                  m()
              },
              ea = ta(function(a) {
                  return a.disabled === !0 && ("form" in a || "label" in a)
              }, {
                  dir: "parentNode",
                  next: "legend"
              });
          try {
              G.apply(D = H.call(v.childNodes), v.childNodes), D[v.childNodes.length].nodeType
          } catch (fa) {
              G = {
                  apply: D.length ? function(a, b) {
                      F.apply(a, H.call(b))
                  } : function(a, b) {
                      var c = a.length,
                          d = 0;
                      while (a[c++] = b[d++]);
                      a.length = c - 1
                  }
              }
          }
  
          function ga(a, b, d, e) {
              var f, h, j, k, l, o, r, s = b && b.ownerDocument,
                  w = b ? b.nodeType : 9;
              if (d = d || [], "string" != typeof a || !a || 1 !== w && 9 !== w && 11 !== w) return d;
              if (!e && ((b ? b.ownerDocument || b : v) !== n && m(b), b = b || n, p)) {
                  if (11 !== w && (l = Z.exec(a)))
                      if (f = l[1]) {
                          if (9 === w) {
                              if (!(j = b.getElementById(f))) return d;
                              if (j.id === f) return d.push(j), d
                          } else if (s && (j = s.getElementById(f)) && t(b, j) && j.id === f) return d.push(j), d
                      } else {
                          if (l[2]) return G.apply(d, b.getElementsByTagName(a)), d;
                          if ((f = l[3]) && c.getElementsByClassName && b.getElementsByClassName) return G.apply(d, b.getElementsByClassName(f)), d
                      }
                  if (c.qsa && !A[a + " "] && (!q || !q.test(a))) {
                      if (1 !== w) s = b, r = a;
                      else if ("object" !== b.nodeName.toLowerCase()) {
                          (k = b.getAttribute("id")) ? k = k.replace(ba, ca): b.setAttribute("id", k = u), o = g(a), h = o.length;
                          while (h--) o[h] = "#" + k + " " + sa(o[h]);
                          r = o.join(","), s = $.test(a) && qa(b.parentNode) || b
                      }
                      if (r) try {
                          return G.apply(d, s.querySelectorAll(r)), d
                      } catch (x) {} finally {
                          k === u && b.removeAttribute("id")
                      }
                  }
              }
              return i(a.replace(P, "$1"), b, d, e)
          }
  
          function ha() {
              var a = [];
  
              function b(c, e) {
                  return a.push(c + " ") > d.cacheLength && delete b[a.shift()], b[c + " "] = e
              }
              return b
          }
  
          function ia(a) {
              return a[u] = !0, a
          }
  
          function ja(a) {
              var b = n.createElement("fieldset");
              try {
                  return !!a(b)
              } catch (c) {
                  return !1
              } finally {
                  b.parentNode && b.parentNode.removeChild(b), b = null
              }
          }
  
          function ka(a, b) {
              var c = a.split("|"),
                  e = c.length;
              while (e--) d.attrHandle[c[e]] = b
          }
  
          function la(a, b) {
              var c = b && a,
                  d = c && 1 === a.nodeType && 1 === b.nodeType && a.sourceIndex - b.sourceIndex;
              if (d) return d;
              if (c)
                  while (c = c.nextSibling)
                      if (c === b) return -1;
              return a ? 1 : -1
          }
  
          function ma(a) {
              return function(b) {
                  var c = b.nodeName.toLowerCase();
                  return "input" === c && b.type === a
              }
          }
  
          function na(a) {
              return function(b) {
                  var c = b.nodeName.toLowerCase();
                  return ("input" === c || "button" === c) && b.type === a
              }
          }
  
          function oa(a) {
              return function(b) {
                  return "form" in b ? b.parentNode && b.disabled === !1 ? "label" in b ? "label" in b.parentNode ? b.parentNode.disabled === a : b.disabled === a : b.isDisabled === a || b.isDisabled !== !a && ea(b) === a : b.disabled === a : "label" in b && b.disabled === a
              }
          }
  
          function pa(a) {
              return ia(function(b) {
                  return b = +b, ia(function(c, d) {
                      var e, f = a([], c.length, b),
                          g = f.length;
                      while (g--) c[e = f[g]] && (c[e] = !(d[e] = c[e]))
                  })
              })
          }
  
          function qa(a) {
              return a && "undefined" != typeof a.getElementsByTagName && a
          }
          c = ga.support = {}, f = ga.isXML = function(a) {
              var b = a && (a.ownerDocument || a).documentElement;
              return !!b && "HTML" !== b.nodeName
          }, m = ga.setDocument = function(a) {
              var b, e, g = a ? a.ownerDocument || a : v;
              return g !== n && 9 === g.nodeType && g.documentElement ? (n = g, o = n.documentElement, p = !f(n), v !== n && (e = n.defaultView) && e.top !== e && (e.addEventListener ? e.addEventListener("unload", da, !1) : e.attachEvent && e.attachEvent("onunload", da)), c.attributes = ja(function(a) {
                  return a.className = "i", !a.getAttribute("className")
              }), c.getElementsByTagName = ja(function(a) {
                  return a.appendChild(n.createComment("")), !a.getElementsByTagName("*").length
              }), c.getElementsByClassName = Y.test(n.getElementsByClassName), c.getById = ja(function(a) {
                  return o.appendChild(a).id = u, !n.getElementsByName || !n.getElementsByName(u).length
              }), c.getById ? (d.filter.ID = function(a) {
                  var b = a.replace(_, aa);
                  return function(a) {
                      return a.getAttribute("id") === b
                  }
              }, d.find.ID = function(a, b) {
                  if ("undefined" != typeof b.getElementById && p) {
                      var c = b.getElementById(a);
                      return c ? [c] : []
                  }
              }) : (d.filter.ID = function(a) {
                  var b = a.replace(_, aa);
                  return function(a) {
                      var c = "undefined" != typeof a.getAttributeNode && a.getAttributeNode("id");
                      return c && c.value === b
                  }
              }, d.find.ID = function(a, b) {
                  if ("undefined" != typeof b.getElementById && p) {
                      var c, d, e, f = b.getElementById(a);
                      if (f) {
                          if (c = f.getAttributeNode("id"), c && c.value === a) return [f];
                          e = b.getElementsByName(a), d = 0;
                          while (f = e[d++])
                              if (c = f.getAttributeNode("id"), c && c.value === a) return [f]
                      }
                      return []
                  }
              }), d.find.TAG = c.getElementsByTagName ? function(a, b) {
                  return "undefined" != typeof b.getElementsByTagName ? b.getElementsByTagName(a) : c.qsa ? b.querySelectorAll(a) : void 0
              } : function(a, b) {
                  var c, d = [],
                      e = 0,
                      f = b.getElementsByTagName(a);
                  if ("*" === a) {
                      while (c = f[e++]) 1 === c.nodeType && d.push(c);
                      return d
                  }
                  return f
              }, d.find.CLASS = c.getElementsByClassName && function(a, b) {
                  if ("undefined" != typeof b.getElementsByClassName && p) return b.getElementsByClassName(a)
              }, r = [], q = [], (c.qsa = Y.test(n.querySelectorAll)) && (ja(function(a) {
                  o.appendChild(a).innerHTML = "<a id='" + u + "'></a><select id='" + u + "-\r\\' msallowcapture=''><option selected=''></option></select>", a.querySelectorAll("[msallowcapture^='']").length && q.push("[*^$]=" + K + "*(?:''|\"\")"), a.querySelectorAll("[selected]").length || q.push("\\[" + K + "*(?:value|" + J + ")"), a.querySelectorAll("[id~=" + u + "-]").length || q.push("~="), a.querySelectorAll(":checked").length || q.push(":checked"), a.querySelectorAll("a#" + u + "+*").length || q.push(".#.+[+~]")
              }), ja(function(a) {
                  a.innerHTML = "<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";
                  var b = n.createElement("input");
                  b.setAttribute("type", "hidden"), a.appendChild(b).setAttribute("name", "D"), a.querySelectorAll("[name=d]").length && q.push("name" + K + "*[*^$|!~]?="), 2 !== a.querySelectorAll(":enabled").length && q.push(":enabled", ":disabled"), o.appendChild(a).disabled = !0, 2 !== a.querySelectorAll(":disabled").length && q.push(":enabled", ":disabled"), a.querySelectorAll("*,:x"), q.push(",.*:")
              })), (c.matchesSelector = Y.test(s = o.matches || o.webkitMatchesSelector || o.mozMatchesSelector || o.oMatchesSelector || o.msMatchesSelector)) && ja(function(a) {
                  c.disconnectedMatch = s.call(a, "*"), s.call(a, "[s!='']:x"), r.push("!=", N)
              }), q = q.length && new RegExp(q.join("|")), r = r.length && new RegExp(r.join("|")), b = Y.test(o.compareDocumentPosition), t = b || Y.test(o.contains) ? function(a, b) {
                  var c = 9 === a.nodeType ? a.documentElement : a,
                      d = b && b.parentNode;
                  return a === d || !(!d || 1 !== d.nodeType || !(c.contains ? c.contains(d) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(d)))
              } : function(a, b) {
                  if (b)
                      while (b = b.parentNode)
                          if (b === a) return !0;
                  return !1
              }, B = b ? function(a, b) {
                  if (a === b) return l = !0, 0;
                  var d = !a.compareDocumentPosition - !b.compareDocumentPosition;
                  return d ? d : (d = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1, 1 & d || !c.sortDetached && b.compareDocumentPosition(a) === d ? a === n || a.ownerDocument === v && t(v, a) ? -1 : b === n || b.ownerDocument === v && t(v, b) ? 1 : k ? I(k, a) - I(k, b) : 0 : 4 & d ? -1 : 1)
              } : function(a, b) {
                  if (a === b) return l = !0, 0;
                  var c, d = 0,
                      e = a.parentNode,
                      f = b.parentNode,
                      g = [a],
                      h = [b];
                  if (!e || !f) return a === n ? -1 : b === n ? 1 : e ? -1 : f ? 1 : k ? I(k, a) - I(k, b) : 0;
                  if (e === f) return la(a, b);
                  c = a;
                  while (c = c.parentNode) g.unshift(c);
                  c = b;
                  while (c = c.parentNode) h.unshift(c);
                  while (g[d] === h[d]) d++;
                  return d ? la(g[d], h[d]) : g[d] === v ? -1 : h[d] === v ? 1 : 0
              }, n) : n
          }, ga.matches = function(a, b) {
              return ga(a, null, null, b)
          }, ga.matchesSelector = function(a, b) {
              if ((a.ownerDocument || a) !== n && m(a), b = b.replace(S, "='$1']"), c.matchesSelector && p && !A[b + " "] && (!r || !r.test(b)) && (!q || !q.test(b))) try {
                  var d = s.call(a, b);
                  if (d || c.disconnectedMatch || a.document && 11 !== a.document.nodeType) return d
              } catch (e) {}
              return ga(b, n, null, [a]).length > 0
          }, ga.contains = function(a, b) {
              return (a.ownerDocument || a) !== n && m(a), t(a, b)
          }, ga.attr = function(a, b) {
              (a.ownerDocument || a) !== n && m(a);
              var e = d.attrHandle[b.toLowerCase()],
                  f = e && C.call(d.attrHandle, b.toLowerCase()) ? e(a, b, !p) : void 0;
              return void 0 !== f ? f : c.attributes || !p ? a.getAttribute(b) : (f = a.getAttributeNode(b)) && f.specified ? f.value : null
          }, ga.escape = function(a) {
              return (a + "").replace(ba, ca)
          }, ga.error = function(a) {
              throw new Error("Syntax error, unrecognized expression: " + a)
          }, ga.uniqueSort = function(a) {
              var b, d = [],
                  e = 0,
                  f = 0;
              if (l = !c.detectDuplicates, k = !c.sortStable && a.slice(0), a.sort(B), l) {
                  while (b = a[f++]) b === a[f] && (e = d.push(f));
                  while (e--) a.splice(d[e], 1)
              }
              return k = null, a
          }, e = ga.getText = function(a) {
              var b, c = "",
                  d = 0,
                  f = a.nodeType;
              if (f) {
                  if (1 === f || 9 === f || 11 === f) {
                      if ("string" == typeof a.textContent) return a.textContent;
                      for (a = a.firstChild; a; a = a.nextSibling) c += e(a)
                  } else if (3 === f || 4 === f) return a.nodeValue
              } else
                  while (b = a[d++]) c += e(b);
              return c
          }, d = ga.selectors = {
              cacheLength: 50,
              createPseudo: ia,
              match: V,
              attrHandle: {},
              find: {},
              relative: {
                  ">": {
                      dir: "parentNode",
                      first: !0
                  },
                  " ": {
                      dir: "parentNode"
                  },
                  "+": {
                      dir: "previousSibling",
                      first: !0
                  },
                  "~": {
                      dir: "previousSibling"
                  }
              },
              preFilter: {
                  ATTR: function(a) {
                      return a[1] = a[1].replace(_, aa), a[3] = (a[3] || a[4] || a[5] || "").replace(_, aa), "~=" === a[2] && (a[3] = " " + a[3] + " "), a.slice(0, 4)
                  },
                  CHILD: function(a) {
                      return a[1] = a[1].toLowerCase(), "nth" === a[1].slice(0, 3) ? (a[3] || ga.error(a[0]), a[4] = +(a[4] ? a[5] + (a[6] || 1) : 2 * ("even" === a[3] || "odd" === a[3])), a[5] = +(a[7] + a[8] || "odd" === a[3])) : a[3] && ga.error(a[0]), a
                  },
                  PSEUDO: function(a) {
                      var b, c = !a[6] && a[2];
                      return V.CHILD.test(a[0]) ? null : (a[3] ? a[2] = a[4] || a[5] || "" : c && T.test(c) && (b = g(c, !0)) && (b = c.indexOf(")", c.length - b) - c.length) && (a[0] = a[0].slice(0, b), a[2] = c.slice(0, b)), a.slice(0, 3))
                  }
              },
              filter: {
                  TAG: function(a) {
                      var b = a.replace(_, aa).toLowerCase();
                      return "*" === a ? function() {
                          return !0
                      } : function(a) {
                          return a.nodeName && a.nodeName.toLowerCase() === b
                      }
                  },
                  CLASS: function(a) {
                      var b = y[a + " "];
                      return b || (b = new RegExp("(^|" + K + ")" + a + "(" + K + "|$)")) && y(a, function(a) {
                          return b.test("string" == typeof a.className && a.className || "undefined" != typeof a.getAttribute && a.getAttribute("class") || "")
                      })
                  },
                  ATTR: function(a, b, c) {
                      return function(d) {
                          var e = ga.attr(d, a);
                          return null == e ? "!=" === b : !b || (e += "", "=" === b ? e === c : "!=" === b ? e !== c : "^=" === b ? c && 0 === e.indexOf(c) : "*=" === b ? c && e.indexOf(c) > -1 : "$=" === b ? c && e.slice(-c.length) === c : "~=" === b ? (" " + e.replace(O, " ") + " ").indexOf(c) > -1 : "|=" === b && (e === c || e.slice(0, c.length + 1) === c + "-"))
                      }
                  },
                  CHILD: function(a, b, c, d, e) {
                      var f = "nth" !== a.slice(0, 3),
                          g = "last" !== a.slice(-4),
                          h = "of-type" === b;
                      return 1 === d && 0 === e ? function(a) {
                          return !!a.parentNode
                      } : function(b, c, i) {
                          var j, k, l, m, n, o, p = f !== g ? "nextSibling" : "previousSibling",
                              q = b.parentNode,
                              r = h && b.nodeName.toLowerCase(),
                              s = !i && !h,
                              t = !1;
                          if (q) {
                              if (f) {
                                  while (p) {
                                      m = b;
                                      while (m = m[p])
                                          if (h ? m.nodeName.toLowerCase() === r : 1 === m.nodeType) return !1;
                                      o = p = "only" === a && !o && "nextSibling"
                                  }
                                  return !0
                              }
                              if (o = [g ? q.firstChild : q.lastChild], g && s) {
                                  m = q, l = m[u] || (m[u] = {}), k = l[m.uniqueID] || (l[m.uniqueID] = {}), j = k[a] || [], n = j[0] === w && j[1], t = n && j[2], m = n && q.childNodes[n];
                                  while (m = ++n && m && m[p] || (t = n = 0) || o.pop())
                                      if (1 === m.nodeType && ++t && m === b) {
                                          k[a] = [w, n, t];
                                          break
                                      }
                              } else if (s && (m = b, l = m[u] || (m[u] = {}), k = l[m.uniqueID] || (l[m.uniqueID] = {}), j = k[a] || [], n = j[0] === w && j[1], t = n), t === !1)
                                  while (m = ++n && m && m[p] || (t = n = 0) || o.pop())
                                      if ((h ? m.nodeName.toLowerCase() === r : 1 === m.nodeType) && ++t && (s && (l = m[u] || (m[u] = {}), k = l[m.uniqueID] || (l[m.uniqueID] = {}), k[a] = [w, t]), m === b)) break;
                              return t -= e, t === d || t % d === 0 && t / d >= 0
                          }
                      }
                  },
                  PSEUDO: function(a, b) {
                      var c, e = d.pseudos[a] || d.setFilters[a.toLowerCase()] || ga.error("unsupported pseudo: " + a);
                      return e[u] ? e(b) : e.length > 1 ? (c = [a, a, "", b], d.setFilters.hasOwnProperty(a.toLowerCase()) ? ia(function(a, c) {
                          var d, f = e(a, b),
                              g = f.length;
                          while (g--) d = I(a, f[g]), a[d] = !(c[d] = f[g])
                      }) : function(a) {
                          return e(a, 0, c)
                      }) : e
                  }
              },
              pseudos: {
                  not: ia(function(a) {
                      var b = [],
                          c = [],
                          d = h(a.replace(P, "$1"));
                      return d[u] ? ia(function(a, b, c, e) {
                          var f, g = d(a, null, e, []),
                              h = a.length;
                          while (h--)(f = g[h]) && (a[h] = !(b[h] = f))
                      }) : function(a, e, f) {
                          return b[0] = a, d(b, null, f, c), b[0] = null, !c.pop()
                      }
                  }),
                  has: ia(function(a) {
                      return function(b) {
                          return ga(a, b).length > 0
                      }
                  }),
                  contains: ia(function(a) {
                      return a = a.replace(_, aa),
                          function(b) {
                              return (b.textContent || b.innerText || e(b)).indexOf(a) > -1
                          }
                  }),
                  lang: ia(function(a) {
                      return U.test(a || "") || ga.error("unsupported lang: " + a), a = a.replace(_, aa).toLowerCase(),
                          function(b) {
                              var c;
                              do
                                  if (c = p ? b.lang : b.getAttribute("xml:lang") || b.getAttribute("lang")) return c = c.toLowerCase(), c === a || 0 === c.indexOf(a + "-"); while ((b = b.parentNode) && 1 === b.nodeType);
                              return !1
                          }
                  }),
                  target: function(b) {
                      var c = a.location && a.location.hash;
                      return c && c.slice(1) === b.id
                  },
                  root: function(a) {
                      return a === o
                  },
                  focus: function(a) {
                      return a === n.activeElement && (!n.hasFocus || n.hasFocus()) && !!(a.type || a.href || ~a.tabIndex)
                  },
                  enabled: oa(!1),
                  disabled: oa(!0),
                  checked: function(a) {
                      var b = a.nodeName.toLowerCase();
                      return "input" === b && !!a.checked || "option" === b && !!a.selected
                  },
                  selected: function(a) {
                      return a.parentNode && a.parentNode.selectedIndex, a.selected === !0
                  },
                  empty: function(a) {
                      for (a = a.firstChild; a; a = a.nextSibling)
                          if (a.nodeType < 6) return !1;
                      return !0
                  },
                  parent: function(a) {
                      return !d.pseudos.empty(a)
                  },
                  header: function(a) {
                      return X.test(a.nodeName)
                  },
                  input: function(a) {
                      return W.test(a.nodeName)
                  },
                  button: function(a) {
                      var b = a.nodeName.toLowerCase();
                      return "input" === b && "button" === a.type || "button" === b
                  },
                  text: function(a) {
                      var b;
                      return "input" === a.nodeName.toLowerCase() && "text" === a.type && (null == (b = a.getAttribute("type")) || "text" === b.toLowerCase())
                  },
                  first: pa(function() {
                      return [0]
                  }),
                  last: pa(function(a, b) {
                      return [b - 1]
                  }),
                  eq: pa(function(a, b, c) {
                      return [c < 0 ? c + b : c]
                  }),
                  even: pa(function(a, b) {
                      for (var c = 0; c < b; c += 2) a.push(c);
                      return a
                  }),
                  odd: pa(function(a, b) {
                      for (var c = 1; c < b; c += 2) a.push(c);
                      return a
                  }),
                  lt: pa(function(a, b, c) {
                      for (var d = c < 0 ? c + b : c; --d >= 0;) a.push(d);
                      return a
                  }),
                  gt: pa(function(a, b, c) {
                      for (var d = c < 0 ? c + b : c; ++d < b;) a.push(d);
                      return a
                  })
              }
          }, d.pseudos.nth = d.pseudos.eq;
          for (b in {
                  radio: !0,
                  checkbox: !0,
                  file: !0,
                  password: !0,
                  image: !0
              }) d.pseudos[b] = ma(b);
          for (b in {
                  submit: !0,
                  reset: !0
              }) d.pseudos[b] = na(b);
  
          function ra() {}
          ra.prototype = d.filters = d.pseudos, d.setFilters = new ra, g = ga.tokenize = function(a, b) {
              var c, e, f, g, h, i, j, k = z[a + " "];
              if (k) return b ? 0 : k.slice(0);
              h = a, i = [], j = d.preFilter;
              while (h) {
                  c && !(e = Q.exec(h)) || (e && (h = h.slice(e[0].length) || h), i.push(f = [])), c = !1, (e = R.exec(h)) && (c = e.shift(), f.push({
                      value: c,
                      type: e[0].replace(P, " ")
                  }), h = h.slice(c.length));
                  for (g in d.filter) !(e = V[g].exec(h)) || j[g] && !(e = j[g](e)) || (c = e.shift(), f.push({
                      value: c,
                      type: g,
                      matches: e
                  }), h = h.slice(c.length));
                  if (!c) break
              }
              return b ? h.length : h ? ga.error(a) : z(a, i).slice(0)
          };
  
          function sa(a) {
              for (var b = 0, c = a.length, d = ""; b < c; b++) d += a[b].value;
              return d
          }
  
          function ta(a, b, c) {
              var d = b.dir,
                  e = b.next,
                  f = e || d,
                  g = c && "parentNode" === f,
                  h = x++;
              return b.first ? function(b, c, e) {
                  while (b = b[d])
                      if (1 === b.nodeType || g) return a(b, c, e);
                  return !1
              } : function(b, c, i) {
                  var j, k, l, m = [w, h];
                  if (i) {
                      while (b = b[d])
                          if ((1 === b.nodeType || g) && a(b, c, i)) return !0
                  } else
                      while (b = b[d])
                          if (1 === b.nodeType || g)
                              if (l = b[u] || (b[u] = {}), k = l[b.uniqueID] || (l[b.uniqueID] = {}), e && e === b.nodeName.toLowerCase()) b = b[d] || b;
                              else {
                                  if ((j = k[f]) && j[0] === w && j[1] === h) return m[2] = j[2];
                                  if (k[f] = m, m[2] = a(b, c, i)) return !0
                              } return !1
              }
          }
  
          function ua(a) {
              return a.length > 1 ? function(b, c, d) {
                  var e = a.length;
                  while (e--)
                      if (!a[e](b, c, d)) return !1;
                  return !0
              } : a[0]
          }
  
          function va(a, b, c) {
              for (var d = 0, e = b.length; d < e; d++) ga(a, b[d], c);
              return c
          }
  
          function wa(a, b, c, d, e) {
              for (var f, g = [], h = 0, i = a.length, j = null != b; h < i; h++)(f = a[h]) && (c && !c(f, d, e) || (g.push(f), j && b.push(h)));
              return g
          }
  
          function xa(a, b, c, d, e, f) {
              return d && !d[u] && (d = xa(d)), e && !e[u] && (e = xa(e, f)), ia(function(f, g, h, i) {
                  var j, k, l, m = [],
                      n = [],
                      o = g.length,
                      p = f || va(b || "*", h.nodeType ? [h] : h, []),
                      q = !a || !f && b ? p : wa(p, m, a, h, i),
                      r = c ? e || (f ? a : o || d) ? [] : g : q;
                  if (c && c(q, r, h, i), d) {
                      j = wa(r, n), d(j, [], h, i), k = j.length;
                      while (k--)(l = j[k]) && (r[n[k]] = !(q[n[k]] = l))
                  }
                  if (f) {
                      if (e || a) {
                          if (e) {
                              j = [], k = r.length;
                              while (k--)(l = r[k]) && j.push(q[k] = l);
                              e(null, r = [], j, i)
                          }
                          k = r.length;
                          while (k--)(l = r[k]) && (j = e ? I(f, l) : m[k]) > -1 && (f[j] = !(g[j] = l))
                      }
                  } else r = wa(r === g ? r.splice(o, r.length) : r), e ? e(null, g, r, i) : G.apply(g, r)
              })
          }
  
          function ya(a) {
              for (var b, c, e, f = a.length, g = d.relative[a[0].type], h = g || d.relative[" "], i = g ? 1 : 0, k = ta(function(a) {
                      return a === b
                  }, h, !0), l = ta(function(a) {
                      return I(b, a) > -1
                  }, h, !0), m = [function(a, c, d) {
                      var e = !g && (d || c !== j) || ((b = c).nodeType ? k(a, c, d) : l(a, c, d));
                      return b = null, e
                  }]; i < f; i++)
                  if (c = d.relative[a[i].type]) m = [ta(ua(m), c)];
                  else {
                      if (c = d.filter[a[i].type].apply(null, a[i].matches), c[u]) {
                          for (e = ++i; e < f; e++)
                              if (d.relative[a[e].type]) break;
                          return xa(i > 1 && ua(m), i > 1 && sa(a.slice(0, i - 1).concat({
                              value: " " === a[i - 2].type ? "*" : ""
                          })).replace(P, "$1"), c, i < e && ya(a.slice(i, e)), e < f && ya(a = a.slice(e)), e < f && sa(a))
                      }
                      m.push(c)
                  }
              return ua(m)
          }
  
          function za(a, b) {
              var c = b.length > 0,
                  e = a.length > 0,
                  f = function(f, g, h, i, k) {
                      var l, o, q, r = 0,
                          s = "0",
                          t = f && [],
                          u = [],
                          v = j,
                          x = f || e && d.find.TAG("*", k),
                          y = w += null == v ? 1 : Math.random() || .1,
                          z = x.length;
                      for (k && (j = g === n || g || k); s !== z && null != (l = x[s]); s++) {
                          if (e && l) {
                              o = 0, g || l.ownerDocument === n || (m(l), h = !p);
                              while (q = a[o++])
                                  if (q(l, g || n, h)) {
                                      i.push(l);
                                      break
                                  }
                              k && (w = y)
                          }
                          c && ((l = !q && l) && r--, f && t.push(l))
                      }
                      if (r += s, c && s !== r) {
                          o = 0;
                          while (q = b[o++]) q(t, u, g, h);
                          if (f) {
                              if (r > 0)
                                  while (s--) t[s] || u[s] || (u[s] = E.call(i));
                              u = wa(u)
                          }
                          G.apply(i, u), k && !f && u.length > 0 && r + b.length > 1 && ga.uniqueSort(i)
                      }
                      return k && (w = y, j = v), t
                  };
              return c ? ia(f) : f
          }
          return h = ga.compile = function(a, b) {
              var c, d = [],
                  e = [],
                  f = A[a + " "];
              if (!f) {
                  b || (b = g(a)), c = b.length;
                  while (c--) f = ya(b[c]), f[u] ? d.push(f) : e.push(f);
                  f = A(a, za(e, d)), f.selector = a
              }
              return f
          }, i = ga.select = function(a, b, c, e) {
              var f, i, j, k, l, m = "function" == typeof a && a,
                  n = !e && g(a = m.selector || a);
              if (c = c || [], 1 === n.length) {
                  if (i = n[0] = n[0].slice(0), i.length > 2 && "ID" === (j = i[0]).type && 9 === b.nodeType && p && d.relative[i[1].type]) {
                      if (b = (d.find.ID(j.matches[0].replace(_, aa), b) || [])[0], !b) return c;
                      m && (b = b.parentNode), a = a.slice(i.shift().value.length)
                  }
                  f = V.needsContext.test(a) ? 0 : i.length;
                  while (f--) {
                      if (j = i[f], d.relative[k = j.type]) break;
                      if ((l = d.find[k]) && (e = l(j.matches[0].replace(_, aa), $.test(i[0].type) && qa(b.parentNode) || b))) {
                          if (i.splice(f, 1), a = e.length && sa(i), !a) return G.apply(c, e), c;
                          break
                      }
                  }
              }
              return (m || h(a, n))(e, b, !p, c, !b || $.test(a) && qa(b.parentNode) || b), c
          }, c.sortStable = u.split("").sort(B).join("") === u, c.detectDuplicates = !!l, m(), c.sortDetached = ja(function(a) {
              return 1 & a.compareDocumentPosition(n.createElement("fieldset"))
          }), ja(function(a) {
              return a.innerHTML = "<a href='#'></a>", "#" === a.firstChild.getAttribute("href")
          }) || ka("type|href|height|width", function(a, b, c) {
              if (!c) return a.getAttribute(b, "type" === b.toLowerCase() ? 1 : 2)
          }), c.attributes && ja(function(a) {
              return a.innerHTML = "<input/>", a.firstChild.setAttribute("value", ""), "" === a.firstChild.getAttribute("value")
          }) || ka("value", function(a, b, c) {
              if (!c && "input" === a.nodeName.toLowerCase()) return a.defaultValue
          }), ja(function(a) {
              return null == a.getAttribute("disabled")
          }) || ka(J, function(a, b, c) {
              var d;
              if (!c) return a[b] === !0 ? b.toLowerCase() : (d = a.getAttributeNode(b)) && d.specified ? d.value : null
          }), ga
      }(a);
      r.find = x, r.expr = x.selectors, r.expr[":"] = r.expr.pseudos, r.uniqueSort = r.unique = x.uniqueSort, r.text = x.getText, r.isXMLDoc = x.isXML, r.contains = x.contains, r.escapeSelector = x.escape;
      var y = function(a, b, c) {
              var d = [],
                  e = void 0 !== c;
              while ((a = a[b]) && 9 !== a.nodeType)
                  if (1 === a.nodeType) {
                      if (e && r(a).is(c)) break;
                      d.push(a)
                  }
              return d
          },
          z = function(a, b) {
              for (var c = []; a; a = a.nextSibling) 1 === a.nodeType && a !== b && c.push(a);
              return c
          },
          A = r.expr.match.needsContext;
  
      function B(a, b) {
          return a.nodeName && a.nodeName.toLowerCase() === b.toLowerCase()
      }
      var C = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,
          D = /^.[^:#\[\.,]*$/;
  
      function E(a, b, c) {
          return r.isFunction(b) ? r.grep(a, function(a, d) {
              return !!b.call(a, d, a) !== c
          }) : b.nodeType ? r.grep(a, function(a) {
              return a === b !== c
          }) : "string" != typeof b ? r.grep(a, function(a) {
              return i.call(b, a) > -1 !== c
          }) : D.test(b) ? r.filter(b, a, c) : (b = r.filter(b, a), r.grep(a, function(a) {
              return i.call(b, a) > -1 !== c && 1 === a.nodeType
          }))
      }
      r.filter = function(a, b, c) {
          var d = b[0];
          return c && (a = ":not(" + a + ")"), 1 === b.length && 1 === d.nodeType ? r.find.matchesSelector(d, a) ? [d] : [] : r.find.matches(a, r.grep(b, function(a) {
              return 1 === a.nodeType
          }))
      }, r.fn.extend({
          find: function(a) {
              var b, c, d = this.length,
                  e = this;
              if ("string" != typeof a) return this.pushStack(r(a).filter(function() {
                  for (b = 0; b < d; b++)
                      if (r.contains(e[b], this)) return !0
              }));
              for (c = this.pushStack([]), b = 0; b < d; b++) r.find(a, e[b], c);
              return d > 1 ? r.uniqueSort(c) : c
          },
          filter: function(a) {
              return this.pushStack(E(this, a || [], !1))
          },
          not: function(a) {
              return this.pushStack(E(this, a || [], !0))
          },
          is: function(a) {
              return !!E(this, "string" == typeof a && A.test(a) ? r(a) : a || [], !1).length
          }
      });
      var F, G = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
          H = r.fn.init = function(a, b, c) {
              var e, f;
              if (!a) return this;
              if (c = c || F, "string" == typeof a) {
                  if (e = "<" === a[0] && ">" === a[a.length - 1] && a.length >= 3 ? [null, a, null] : G.exec(a), !e || !e[1] && b) return !b || b.jquery ? (b || c).find(a) : this.constructor(b).find(a);
                  if (e[1]) {
                      if (b = b instanceof r ? b[0] : b, r.merge(this, r.parseHTML(e[1], b && b.nodeType ? b.ownerDocument || b : d, !0)), C.test(e[1]) && r.isPlainObject(b))
                          for (e in b) r.isFunction(this[e]) ? this[e](b[e]) : this.attr(e, b[e]);
                      return this
                  }
                  return f = d.getElementById(e[2]), f && (this[0] = f, this.length = 1), this
              }
              return a.nodeType ? (this[0] = a, this.length = 1, this) : r.isFunction(a) ? void 0 !== c.ready ? c.ready(a) : a(r) : r.makeArray(a, this)
          };
      H.prototype = r.fn, F = r(d);
      var I = /^(?:parents|prev(?:Until|All))/,
          J = {
              children: !0,
              contents: !0,
              next: !0,
              prev: !0
          };
      r.fn.extend({
          has: function(a) {
              var b = r(a, this),
                  c = b.length;
              return this.filter(function() {
                  for (var a = 0; a < c; a++)
                      if (r.contains(this, b[a])) return !0
              })
          },
          closest: function(a, b) {
              var c, d = 0,
                  e = this.length,
                  f = [],
                  g = "string" != typeof a && r(a);
              if (!A.test(a))
                  for (; d < e; d++)
                      for (c = this[d]; c && c !== b; c = c.parentNode)
                          if (c.nodeType < 11 && (g ? g.index(c) > -1 : 1 === c.nodeType && r.find.matchesSelector(c, a))) {
                              f.push(c);
                              break
                          }
              return this.pushStack(f.length > 1 ? r.uniqueSort(f) : f)
          },
          index: function(a) {
              return a ? "string" == typeof a ? i.call(r(a), this[0]) : i.call(this, a.jquery ? a[0] : a) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1
          },
          add: function(a, b) {
              return this.pushStack(r.uniqueSort(r.merge(this.get(), r(a, b))))
          },
          addBack: function(a) {
              return this.add(null == a ? this.prevObject : this.prevObject.filter(a))
          }
      });
  
      function K(a, b) {
          while ((a = a[b]) && 1 !== a.nodeType);
          return a
      }
      r.each({
          parent: function(a) {
              var b = a.parentNode;
              return b && 11 !== b.nodeType ? b : null
          },
          parents: function(a) {
              return y(a, "parentNode")
          },
          parentsUntil: function(a, b, c) {
              return y(a, "parentNode", c)
          },
          next: function(a) {
              return K(a, "nextSibling")
          },
          prev: function(a) {
              return K(a, "previousSibling")
          },
          nextAll: function(a) {
              return y(a, "nextSibling")
          },
          prevAll: function(a) {
              return y(a, "previousSibling")
          },
          nextUntil: function(a, b, c) {
              return y(a, "nextSibling", c)
          },
          prevUntil: function(a, b, c) {
              return y(a, "previousSibling", c)
          },
          siblings: function(a) {
              return z((a.parentNode || {}).firstChild, a)
          },
          children: function(a) {
              return z(a.firstChild)
          },
          contents: function(a) {
              return B(a, "iframe") ? a.contentDocument : (B(a, "template") && (a = a.content || a), r.merge([], a.childNodes))
          }
      }, function(a, b) {
          r.fn[a] = function(c, d) {
              var e = r.map(this, b, c);
              return "Until" !== a.slice(-5) && (d = c), d && "string" == typeof d && (e = r.filter(d, e)), this.length > 1 && (J[a] || r.uniqueSort(e), I.test(a) && e.reverse()), this.pushStack(e)
          }
      });
      var L = /[^\x20\t\r\n\f]+/g;
  
      function M(a) {
          var b = {};
          return r.each(a.match(L) || [], function(a, c) {
              b[c] = !0
          }), b
      }
      r.Callbacks = function(a) {
          a = "string" == typeof a ? M(a) : r.extend({}, a);
          var b, c, d, e, f = [],
              g = [],
              h = -1,
              i = function() {
                  for (e = e || a.once, d = b = !0; g.length; h = -1) {
                      c = g.shift();
                      while (++h < f.length) f[h].apply(c[0], c[1]) === !1 && a.stopOnFalse && (h = f.length, c = !1)
                  }
                  a.memory || (c = !1), b = !1, e && (f = c ? [] : "")
              },
              j = {
                  add: function() {
                      return f && (c && !b && (h = f.length - 1, g.push(c)), function d(b) {
                          r.each(b, function(b, c) {
                              r.isFunction(c) ? a.unique && j.has(c) || f.push(c) : c && c.length && "string" !== r.type(c) && d(c)
                          })
                      }(arguments), c && !b && i()), this
                  },
                  remove: function() {
                      return r.each(arguments, function(a, b) {
                          var c;
                          while ((c = r.inArray(b, f, c)) > -1) f.splice(c, 1), c <= h && h--
                      }), this
                  },
                  has: function(a) {
                      return a ? r.inArray(a, f) > -1 : f.length > 0
                  },
                  empty: function() {
                      return f && (f = []), this
                  },
                  disable: function() {
                      return e = g = [], f = c = "", this
                  },
                  disabled: function() {
                      return !f
                  },
                  lock: function() {
                      return e = g = [], c || b || (f = c = ""), this
                  },
                  locked: function() {
                      return !!e
                  },
                  fireWith: function(a, c) {
                      return e || (c = c || [], c = [a, c.slice ? c.slice() : c], g.push(c), b || i()), this
                  },
                  fire: function() {
                      return j.fireWith(this, arguments), this
                  },
                  fired: function() {
                      return !!d
                  }
              };
          return j
      };
  
      function N(a) {
          return a
      }
  
      function O(a) {
          throw a
      }
  
      function P(a, b, c, d) {
          var e;
          try {
              a && r.isFunction(e = a.promise) ? e.call(a).done(b).fail(c) : a && r.isFunction(e = a.then) ? e.call(a, b, c) : b.apply(void 0, [a].slice(d))
          } catch (a) {
              c.apply(void 0, [a])
          }
      }
      r.extend({
          Deferred: function(b) {
              var c = [
                      ["notify", "progress", r.Callbacks("memory"), r.Callbacks("memory"), 2],
                      ["resolve", "done", r.Callbacks("once memory"), r.Callbacks("once memory"), 0, "resolved"],
                      ["reject", "fail", r.Callbacks("once memory"), r.Callbacks("once memory"), 1, "rejected"]
                  ],
                  d = "pending",
                  e = {
                      state: function() {
                          return d
                      },
                      always: function() {
                          return f.done(arguments).fail(arguments), this
                      },
                      "catch": function(a) {
                          return e.then(null, a)
                      },
                      pipe: function() {
                          var a = arguments;
                          return r.Deferred(function(b) {
                              r.each(c, function(c, d) {
                                  var e = r.isFunction(a[d[4]]) && a[d[4]];
                                  f[d[1]](function() {
                                      var a = e && e.apply(this, arguments);
                                      a && r.isFunction(a.promise) ? a.promise().progress(b.notify).done(b.resolve).fail(b.reject) : b[d[0] + "With"](this, e ? [a] : arguments)
                                  })
                              }), a = null
                          }).promise()
                      },
                      then: function(b, d, e) {
                          var f = 0;
  
                          function g(b, c, d, e) {
                              return function() {
                                  var h = this,
                                      i = arguments,
                                      j = function() {
                                          var a, j;
                                          if (!(b < f)) {
                                              if (a = d.apply(h, i), a === c.promise()) throw new TypeError("Thenable self-resolution");
                                              j = a && ("object" == typeof a || "function" == typeof a) && a.then, r.isFunction(j) ? e ? j.call(a, g(f, c, N, e), g(f, c, O, e)) : (f++, j.call(a, g(f, c, N, e), g(f, c, O, e), g(f, c, N, c.notifyWith))) : (d !== N && (h = void 0, i = [a]), (e || c.resolveWith)(h, i))
                                          }
                                      },
                                      k = e ? j : function() {
                                          try {
                                              j()
                                          } catch (a) {
                                              r.Deferred.exceptionHook && r.Deferred.exceptionHook(a, k.stackTrace), b + 1 >= f && (d !== O && (h = void 0, i = [a]), c.rejectWith(h, i))
                                          }
                                      };
                                  b ? k() : (r.Deferred.getStackHook && (k.stackTrace = r.Deferred.getStackHook()), a.setTimeout(k))
                              }
                          }
                          return r.Deferred(function(a) {
                              c[0][3].add(g(0, a, r.isFunction(e) ? e : N, a.notifyWith)), c[1][3].add(g(0, a, r.isFunction(b) ? b : N)), c[2][3].add(g(0, a, r.isFunction(d) ? d : O))
                          }).promise()
                      },
                      promise: function(a) {
                          return null != a ? r.extend(a, e) : e
                      }
                  },
                  f = {};
              return r.each(c, function(a, b) {
                  var g = b[2],
                      h = b[5];
                  e[b[1]] = g.add, h && g.add(function() {
                      d = h
                  }, c[3 - a][2].disable, c[0][2].lock), g.add(b[3].fire), f[b[0]] = function() {
                      return f[b[0] + "With"](this === f ? void 0 : this, arguments), this
                  }, f[b[0] + "With"] = g.fireWith
              }), e.promise(f), b && b.call(f, f), f
          },
          when: function(a) {
              var b = arguments.length,
                  c = b,
                  d = Array(c),
                  e = f.call(arguments),
                  g = r.Deferred(),
                  h = function(a) {
                      return function(c) {
                          d[a] = this, e[a] = arguments.length > 1 ? f.call(arguments) : c, --b || g.resolveWith(d, e)
                      }
                  };
              if (b <= 1 && (P(a, g.done(h(c)).resolve, g.reject, !b), "pending" === g.state() || r.isFunction(e[c] && e[c].then))) return g.then();
              while (c--) P(e[c], h(c), g.reject);
              return g.promise()
          }
      });
      var Q = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
      r.Deferred.exceptionHook = function(b, c) {
          a.console && a.console.warn && b && Q.test(b.name) && a.console.warn("jQuery.Deferred exception: " + b.message, b.stack, c)
      }, r.readyException = function(b) {
          a.setTimeout(function() {
              throw b
          })
      };
      var R = r.Deferred();
      r.fn.ready = function(a) {
          return R.then(a)["catch"](function(a) {
              r.readyException(a)
          }), this
      }, r.extend({
          isReady: !1,
          readyWait: 1,
          ready: function(a) {
              (a === !0 ? --r.readyWait : r.isReady) || (r.isReady = !0, a !== !0 && --r.readyWait > 0 || R.resolveWith(d, [r]))
          }
      }), r.ready.then = R.then;
  
      function S() {
          d.removeEventListener("DOMContentLoaded", S),
              a.removeEventListener("load", S), r.ready()
      }
      "complete" === d.readyState || "loading" !== d.readyState && !d.documentElement.doScroll ? a.setTimeout(r.ready) : (d.addEventListener("DOMContentLoaded", S), a.addEventListener("load", S));
      var T = function(a, b, c, d, e, f, g) {
              var h = 0,
                  i = a.length,
                  j = null == c;
              if ("object" === r.type(c)) {
                  e = !0;
                  for (h in c) T(a, b, h, c[h], !0, f, g)
              } else if (void 0 !== d && (e = !0, r.isFunction(d) || (g = !0), j && (g ? (b.call(a, d), b = null) : (j = b, b = function(a, b, c) {
                      return j.call(r(a), c)
                  })), b))
                  for (; h < i; h++) b(a[h], c, g ? d : d.call(a[h], h, b(a[h], c)));
              return e ? a : j ? b.call(a) : i ? b(a[0], c) : f
          },
          U = function(a) {
              return 1 === a.nodeType || 9 === a.nodeType || !+a.nodeType
          };
  
      function V() {
          this.expando = r.expando + V.uid++
      }
      V.uid = 1, V.prototype = {
          cache: function(a) {
              var b = a[this.expando];
              return b || (b = {}, U(a) && (a.nodeType ? a[this.expando] = b : Object.defineProperty(a, this.expando, {
                  value: b,
                  configurable: !0
              }))), b
          },
          set: function(a, b, c) {
              var d, e = this.cache(a);
              if ("string" == typeof b) e[r.camelCase(b)] = c;
              else
                  for (d in b) e[r.camelCase(d)] = b[d];
              return e
          },
          get: function(a, b) {
              return void 0 === b ? this.cache(a) : a[this.expando] && a[this.expando][r.camelCase(b)]
          },
          access: function(a, b, c) {
              return void 0 === b || b && "string" == typeof b && void 0 === c ? this.get(a, b) : (this.set(a, b, c), void 0 !== c ? c : b)
          },
          remove: function(a, b) {
              var c, d = a[this.expando];
              if (void 0 !== d) {
                  if (void 0 !== b) {
                      Array.isArray(b) ? b = b.map(r.camelCase) : (b = r.camelCase(b), b = b in d ? [b] : b.match(L) || []), c = b.length;
                      while (c--) delete d[b[c]]
                  }(void 0 === b || r.isEmptyObject(d)) && (a.nodeType ? a[this.expando] = void 0 : delete a[this.expando])
              }
          },
          hasData: function(a) {
              var b = a[this.expando];
              return void 0 !== b && !r.isEmptyObject(b)
          }
      };
      var W = new V,
          X = new V,
          Y = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
          Z = /[A-Z]/g;
  
      function $(a) {
          return "true" === a || "false" !== a && ("null" === a ? null : a === +a + "" ? +a : Y.test(a) ? JSON.parse(a) : a)
      }
  
      function _(a, b, c) {
          var d;
          if (void 0 === c && 1 === a.nodeType)
              if (d = "data-" + b.replace(Z, "-$&").toLowerCase(), c = a.getAttribute(d), "string" == typeof c) {
                  try {
                      c = $(c)
                  } catch (e) {}
                  X.set(a, b, c)
              } else c = void 0;
          return c
      }
      r.extend({
          hasData: function(a) {
              return X.hasData(a) || W.hasData(a)
          },
          data: function(a, b, c) {
              return X.access(a, b, c)
          },
          removeData: function(a, b) {
              X.remove(a, b)
          },
          _data: function(a, b, c) {
              return W.access(a, b, c)
          },
          _removeData: function(a, b) {
              W.remove(a, b)
          }
      }), r.fn.extend({
          data: function(a, b) {
              var c, d, e, f = this[0],
                  g = f && f.attributes;
              if (void 0 === a) {
                  if (this.length && (e = X.get(f), 1 === f.nodeType && !W.get(f, "hasDataAttrs"))) {
                      c = g.length;
                      while (c--) g[c] && (d = g[c].name, 0 === d.indexOf("data-") && (d = r.camelCase(d.slice(5)), _(f, d, e[d])));
                      W.set(f, "hasDataAttrs", !0)
                  }
                  return e
              }
              return "object" == typeof a ? this.each(function() {
                  X.set(this, a)
              }) : T(this, function(b) {
                  var c;
                  if (f && void 0 === b) {
                      if (c = X.get(f, a), void 0 !== c) return c;
                      if (c = _(f, a), void 0 !== c) return c
                  } else this.each(function() {
                      X.set(this, a, b)
                  })
              }, null, b, arguments.length > 1, null, !0)
          },
          removeData: function(a) {
              return this.each(function() {
                  X.remove(this, a)
              })
          }
      }), r.extend({
          queue: function(a, b, c) {
              var d;
              if (a) return b = (b || "fx") + "queue", d = W.get(a, b), c && (!d || Array.isArray(c) ? d = W.access(a, b, r.makeArray(c)) : d.push(c)), d || []
          },
          dequeue: function(a, b) {
              b = b || "fx";
              var c = r.queue(a, b),
                  d = c.length,
                  e = c.shift(),
                  f = r._queueHooks(a, b),
                  g = function() {
                      r.dequeue(a, b)
                  };
              "inprogress" === e && (e = c.shift(), d--), e && ("fx" === b && c.unshift("inprogress"), delete f.stop, e.call(a, g, f)), !d && f && f.empty.fire()
          },
          _queueHooks: function(a, b) {
              var c = b + "queueHooks";
              return W.get(a, c) || W.access(a, c, {
                  empty: r.Callbacks("once memory").add(function() {
                      W.remove(a, [b + "queue", c])
                  })
              })
          }
      }), r.fn.extend({
          queue: function(a, b) {
              var c = 2;
              return "string" != typeof a && (b = a, a = "fx", c--), arguments.length < c ? r.queue(this[0], a) : void 0 === b ? this : this.each(function() {
                  var c = r.queue(this, a, b);
                  r._queueHooks(this, a), "fx" === a && "inprogress" !== c[0] && r.dequeue(this, a)
              })
          },
          dequeue: function(a) {
              return this.each(function() {
                  r.dequeue(this, a)
              })
          },
          clearQueue: function(a) {
              return this.queue(a || "fx", [])
          },
          promise: function(a, b) {
              var c, d = 1,
                  e = r.Deferred(),
                  f = this,
                  g = this.length,
                  h = function() {
                      --d || e.resolveWith(f, [f])
                  };
              "string" != typeof a && (b = a, a = void 0), a = a || "fx";
              while (g--) c = W.get(f[g], a + "queueHooks"), c && c.empty && (d++, c.empty.add(h));
              return h(), e.promise(b)
          }
      });
      var aa = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
          ba = new RegExp("^(?:([+-])=|)(" + aa + ")([a-z%]*)$", "i"),
          ca = ["Top", "Right", "Bottom", "Left"],
          da = function(a, b) {
              return a = b || a, "none" === a.style.display || "" === a.style.display && r.contains(a.ownerDocument, a) && "none" === r.css(a, "display")
          },
          ea = function(a, b, c, d) {
              var e, f, g = {};
              for (f in b) g[f] = a.style[f], a.style[f] = b[f];
              e = c.apply(a, d || []);
              for (f in b) a.style[f] = g[f];
              return e
          };
  
      function fa(a, b, c, d) {
          var e, f = 1,
              g = 20,
              h = d ? function() {
                  return d.cur()
              } : function() {
                  return r.css(a, b, "")
              },
              i = h(),
              j = c && c[3] || (r.cssNumber[b] ? "" : "px"),
              k = (r.cssNumber[b] || "px" !== j && +i) && ba.exec(r.css(a, b));
          if (k && k[3] !== j) {
              j = j || k[3], c = c || [], k = +i || 1;
              do f = f || ".5", k /= f, r.style(a, b, k + j); while (f !== (f = h() / i) && 1 !== f && --g)
          }
          return c && (k = +k || +i || 0, e = c[1] ? k + (c[1] + 1) * c[2] : +c[2], d && (d.unit = j, d.start = k, d.end = e)), e
      }
      var ga = {};
  
      function ha(a) {
          var b, c = a.ownerDocument,
              d = a.nodeName,
              e = ga[d];
          return e ? e : (b = c.body.appendChild(c.createElement(d)), e = r.css(b, "display"), b.parentNode.removeChild(b), "none" === e && (e = "block"), ga[d] = e, e)
      }
  
      function ia(a, b) {
          for (var c, d, e = [], f = 0, g = a.length; f < g; f++) d = a[f], d.style && (c = d.style.display, b ? ("none" === c && (e[f] = W.get(d, "display") || null, e[f] || (d.style.display = "")), "" === d.style.display && da(d) && (e[f] = ha(d))) : "none" !== c && (e[f] = "none", W.set(d, "display", c)));
          for (f = 0; f < g; f++) null != e[f] && (a[f].style.display = e[f]);
          return a
      }
      r.fn.extend({
          show: function() {
              return ia(this, !0)
          },
          hide: function() {
              return ia(this)
          },
          toggle: function(a) {
              return "boolean" == typeof a ? a ? this.show() : this.hide() : this.each(function() {
                  da(this) ? r(this).show() : r(this).hide()
              })
          }
      });
      var ja = /^(?:checkbox|radio)$/i,
          ka = /<([a-z][^\/\0>\x20\t\r\n\f]+)/i,
          la = /^$|\/(?:java|ecma)script/i,
          ma = {
              option: [1, "<select multiple='multiple'>", "</select>"],
              thead: [1, "<table>", "</table>"],
              col: [2, "<table><colgroup>", "</colgroup></table>"],
              tr: [2, "<table><tbody>", "</tbody></table>"],
              td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
              _default: [0, "", ""]
          };
      ma.optgroup = ma.option, ma.tbody = ma.tfoot = ma.colgroup = ma.caption = ma.thead, ma.th = ma.td;
  
      function na(a, b) {
          var c;
          return c = "undefined" != typeof a.getElementsByTagName ? a.getElementsByTagName(b || "*") : "undefined" != typeof a.querySelectorAll ? a.querySelectorAll(b || "*") : [], void 0 === b || b && B(a, b) ? r.merge([a], c) : c
      }
  
      function oa(a, b) {
          for (var c = 0, d = a.length; c < d; c++) W.set(a[c], "globalEval", !b || W.get(b[c], "globalEval"))
      }
      var pa = /<|&#?\w+;/;
  
      function qa(a, b, c, d, e) {
          for (var f, g, h, i, j, k, l = b.createDocumentFragment(), m = [], n = 0, o = a.length; n < o; n++)
              if (f = a[n], f || 0 === f)
                  if ("object" === r.type(f)) r.merge(m, f.nodeType ? [f] : f);
                  else if (pa.test(f)) {
              g = g || l.appendChild(b.createElement("div")), h = (ka.exec(f) || ["", ""])[1].toLowerCase(), i = ma[h] || ma._default, g.innerHTML = i[1] + r.htmlPrefilter(f) + i[2], k = i[0];
              while (k--) g = g.lastChild;
              r.merge(m, g.childNodes), g = l.firstChild, g.textContent = ""
          } else m.push(b.createTextNode(f));
          l.textContent = "", n = 0;
          while (f = m[n++])
              if (d && r.inArray(f, d) > -1) e && e.push(f);
              else if (j = r.contains(f.ownerDocument, f), g = na(l.appendChild(f), "script"), j && oa(g), c) {
              k = 0;
              while (f = g[k++]) la.test(f.type || "") && c.push(f)
          }
          return l
      }! function() {
          var a = d.createDocumentFragment(),
              b = a.appendChild(d.createElement("div")),
              c = d.createElement("input");
          c.setAttribute("type", "radio"), c.setAttribute("checked", "checked"), c.setAttribute("name", "t"), b.appendChild(c), o.checkClone = b.cloneNode(!0).cloneNode(!0).lastChild.checked, b.innerHTML = "<textarea>x</textarea>", o.noCloneChecked = !!b.cloneNode(!0).lastChild.defaultValue
      }();
      var ra = d.documentElement,
          sa = /^key/,
          ta = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
          ua = /^([^.]*)(?:\.(.+)|)/;
  
      function va() {
          return !0
      }
  
      function wa() {
          return !1
      }
  
      function xa() {
          try {
              return d.activeElement
          } catch (a) {}
      }
  
      function ya(a, b, c, d, e, f) {
          var g, h;
          if ("object" == typeof b) {
              "string" != typeof c && (d = d || c, c = void 0);
              for (h in b) ya(a, h, c, d, b[h], f);
              return a
          }
          if (null == d && null == e ? (e = c, d = c = void 0) : null == e && ("string" == typeof c ? (e = d, d = void 0) : (e = d, d = c, c = void 0)), e === !1) e = wa;
          else if (!e) return a;
          return 1 === f && (g = e, e = function(a) {
              return r().off(a), g.apply(this, arguments)
          }, e.guid = g.guid || (g.guid = r.guid++)), a.each(function() {
              r.event.add(this, b, e, d, c)
          })
      }
      r.event = {
          global: {},
          add: function(a, b, c, d, e) {
              var f, g, h, i, j, k, l, m, n, o, p, q = W.get(a);
              if (q) {
                  c.handler && (f = c, c = f.handler, e = f.selector), e && r.find.matchesSelector(ra, e), c.guid || (c.guid = r.guid++), (i = q.events) || (i = q.events = {}), (g = q.handle) || (g = q.handle = function(b) {
                      return "undefined" != typeof r && r.event.triggered !== b.type ? r.event.dispatch.apply(a, arguments) : void 0
                  }), b = (b || "").match(L) || [""], j = b.length;
                  while (j--) h = ua.exec(b[j]) || [], n = p = h[1], o = (h[2] || "").split(".").sort(), n && (l = r.event.special[n] || {}, n = (e ? l.delegateType : l.bindType) || n, l = r.event.special[n] || {}, k = r.extend({
                      type: n,
                      origType: p,
                      data: d,
                      handler: c,
                      guid: c.guid,
                      selector: e,
                      needsContext: e && r.expr.match.needsContext.test(e),
                      namespace: o.join(".")
                  }, f), (m = i[n]) || (m = i[n] = [], m.delegateCount = 0, l.setup && l.setup.call(a, d, o, g) !== !1 || a.addEventListener && a.addEventListener(n, g)), l.add && (l.add.call(a, k), k.handler.guid || (k.handler.guid = c.guid)), e ? m.splice(m.delegateCount++, 0, k) : m.push(k), r.event.global[n] = !0)
              }
          },
          remove: function(a, b, c, d, e) {
              var f, g, h, i, j, k, l, m, n, o, p, q = W.hasData(a) && W.get(a);
              if (q && (i = q.events)) {
                  b = (b || "").match(L) || [""], j = b.length;
                  while (j--)
                      if (h = ua.exec(b[j]) || [], n = p = h[1], o = (h[2] || "").split(".").sort(), n) {
                          l = r.event.special[n] || {}, n = (d ? l.delegateType : l.bindType) || n, m = i[n] || [], h = h[2] && new RegExp("(^|\\.)" + o.join("\\.(?:.*\\.|)") + "(\\.|$)"), g = f = m.length;
                          while (f--) k = m[f], !e && p !== k.origType || c && c.guid !== k.guid || h && !h.test(k.namespace) || d && d !== k.selector && ("**" !== d || !k.selector) || (m.splice(f, 1), k.selector && m.delegateCount--, l.remove && l.remove.call(a, k));
                          g && !m.length && (l.teardown && l.teardown.call(a, o, q.handle) !== !1 || r.removeEvent(a, n, q.handle), delete i[n])
                      } else
                          for (n in i) r.event.remove(a, n + b[j], c, d, !0);
                  r.isEmptyObject(i) && W.remove(a, "handle events")
              }
          },
          dispatch: function(a) {
              var b = r.event.fix(a),
                  c, d, e, f, g, h, i = new Array(arguments.length),
                  j = (W.get(this, "events") || {})[b.type] || [],
                  k = r.event.special[b.type] || {};
              for (i[0] = b, c = 1; c < arguments.length; c++) i[c] = arguments[c];
              if (b.delegateTarget = this, !k.preDispatch || k.preDispatch.call(this, b) !== !1) {
                  h = r.event.handlers.call(this, b, j), c = 0;
                  while ((f = h[c++]) && !b.isPropagationStopped()) {
                      b.currentTarget = f.elem, d = 0;
                      while ((g = f.handlers[d++]) && !b.isImmediatePropagationStopped()) b.rnamespace && !b.rnamespace.test(g.namespace) || (b.handleObj = g, b.data = g.data, e = ((r.event.special[g.origType] || {}).handle || g.handler).apply(f.elem, i), void 0 !== e && (b.result = e) === !1 && (b.preventDefault(), b.stopPropagation()))
                  }
                  return k.postDispatch && k.postDispatch.call(this, b), b.result
              }
          },
          handlers: function(a, b) {
              var c, d, e, f, g, h = [],
                  i = b.delegateCount,
                  j = a.target;
              if (i && j.nodeType && !("click" === a.type && a.button >= 1))
                  for (; j !== this; j = j.parentNode || this)
                      if (1 === j.nodeType && ("click" !== a.type || j.disabled !== !0)) {
                          for (f = [], g = {}, c = 0; c < i; c++) d = b[c], e = d.selector + " ", void 0 === g[e] && (g[e] = d.needsContext ? r(e, this).index(j) > -1 : r.find(e, this, null, [j]).length), g[e] && f.push(d);
                          f.length && h.push({
                              elem: j,
                              handlers: f
                          })
                      }
              return j = this, i < b.length && h.push({
                  elem: j,
                  handlers: b.slice(i)
              }), h
          },
          addProp: function(a, b) {
              Object.defineProperty(r.Event.prototype, a, {
                  enumerable: !0,
                  configurable: !0,
                  get: r.isFunction(b) ? function() {
                      if (this.originalEvent) return b(this.originalEvent)
                  } : function() {
                      if (this.originalEvent) return this.originalEvent[a]
                  },
                  set: function(b) {
                      Object.defineProperty(this, a, {
                          enumerable: !0,
                          configurable: !0,
                          writable: !0,
                          value: b
                      })
                  }
              })
          },
          fix: function(a) {
              return a[r.expando] ? a : new r.Event(a)
          },
          special: {
              load: {
                  noBubble: !0
              },
              focus: {
                  trigger: function() {
                      if (this !== xa() && this.focus) return this.focus(), !1
                  },
                  delegateType: "focusin"
              },
              blur: {
                  trigger: function() {
                      if (this === xa() && this.blur) return this.blur(), !1
                  },
                  delegateType: "focusout"
              },
              click: {
                  trigger: function() {
                      if ("checkbox" === this.type && this.click && B(this, "input")) return this.click(), !1
                  },
                  _default: function(a) {
                      return B(a.target, "a")
                  }
              },
              beforeunload: {
                  postDispatch: function(a) {
                      void 0 !== a.result && a.originalEvent && (a.originalEvent.returnValue = a.result)
                  }
              }
          }
      }, r.removeEvent = function(a, b, c) {
          a.removeEventListener && a.removeEventListener(b, c)
      }, r.Event = function(a, b) {
          return this instanceof r.Event ? (a && a.type ? (this.originalEvent = a, this.type = a.type, this.isDefaultPrevented = a.defaultPrevented || void 0 === a.defaultPrevented && a.returnValue === !1 ? va : wa, this.target = a.target && 3 === a.target.nodeType ? a.target.parentNode : a.target, this.currentTarget = a.currentTarget, this.relatedTarget = a.relatedTarget) : this.type = a, b && r.extend(this, b), this.timeStamp = a && a.timeStamp || r.now(), void(this[r.expando] = !0)) : new r.Event(a, b)
      }, r.Event.prototype = {
          constructor: r.Event,
          isDefaultPrevented: wa,
          isPropagationStopped: wa,
          isImmediatePropagationStopped: wa,
          isSimulated: !1,
          preventDefault: function() {
              var a = this.originalEvent;
              this.isDefaultPrevented = va, a && !this.isSimulated && a.preventDefault()
          },
          stopPropagation: function() {
              var a = this.originalEvent;
              this.isPropagationStopped = va, a && !this.isSimulated && a.stopPropagation()
          },
          stopImmediatePropagation: function() {
              var a = this.originalEvent;
              this.isImmediatePropagationStopped = va, a && !this.isSimulated && a.stopImmediatePropagation(), this.stopPropagation()
          }
      }, r.each({
          altKey: !0,
          bubbles: !0,
          cancelable: !0,
          changedTouches: !0,
          ctrlKey: !0,
          detail: !0,
          eventPhase: !0,
          metaKey: !0,
          pageX: !0,
          pageY: !0,
          shiftKey: !0,
          view: !0,
          "char": !0,
          charCode: !0,
          key: !0,
          keyCode: !0,
          button: !0,
          buttons: !0,
          clientX: !0,
          clientY: !0,
          offsetX: !0,
          offsetY: !0,
          pointerId: !0,
          pointerType: !0,
          screenX: !0,
          screenY: !0,
          targetTouches: !0,
          toElement: !0,
          touches: !0,
          which: function(a) {
              var b = a.button;
              return null == a.which && sa.test(a.type) ? null != a.charCode ? a.charCode : a.keyCode : !a.which && void 0 !== b && ta.test(a.type) ? 1 & b ? 1 : 2 & b ? 3 : 4 & b ? 2 : 0 : a.which
          }
      }, r.event.addProp), r.each({
          mouseenter: "mouseover",
          mouseleave: "mouseout",
          pointerenter: "pointerover",
          pointerleave: "pointerout"
      }, function(a, b) {
          r.event.special[a] = {
              delegateType: b,
              bindType: b,
              handle: function(a) {
                  var c, d = this,
                      e = a.relatedTarget,
                      f = a.handleObj;
                  return e && (e === d || r.contains(d, e)) || (a.type = f.origType, c = f.handler.apply(this, arguments), a.type = b), c
              }
          }
      }), r.fn.extend({
          on: function(a, b, c, d) {
              return ya(this, a, b, c, d)
          },
          one: function(a, b, c, d) {
              return ya(this, a, b, c, d, 1)
          },
          off: function(a, b, c) {
              var d, e;
              if (a && a.preventDefault && a.handleObj) return d = a.handleObj, r(a.delegateTarget).off(d.namespace ? d.origType + "." + d.namespace : d.origType, d.selector, d.handler), this;
              if ("object" == typeof a) {
                  for (e in a) this.off(e, b, a[e]);
                  return this
              }
              return b !== !1 && "function" != typeof b || (c = b, b = void 0), c === !1 && (c = wa), this.each(function() {
                  r.event.remove(this, a, c, b)
              })
          }
      });
      var za = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
          Aa = /<script|<style|<link/i,
          Ba = /checked\s*(?:[^=]|=\s*.checked.)/i,
          Ca = /^true\/(.*)/,
          Da = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  
      function Ea(a, b) {
          return B(a, "table") && B(11 !== b.nodeType ? b : b.firstChild, "tr") ? r(">tbody", a)[0] || a : a
      }
  
      function Fa(a) {
          return a.type = (null !== a.getAttribute("type")) + "/" + a.type, a
      }
  
      function Ga(a) {
          var b = Ca.exec(a.type);
          return b ? a.type = b[1] : a.removeAttribute("type"), a
      }
  
      function Ha(a, b) {
          var c, d, e, f, g, h, i, j;
          if (1 === b.nodeType) {
              if (W.hasData(a) && (f = W.access(a), g = W.set(b, f), j = f.events)) {
                  delete g.handle, g.events = {};
                  for (e in j)
                      for (c = 0, d = j[e].length; c < d; c++) r.event.add(b, e, j[e][c])
              }
              X.hasData(a) && (h = X.access(a), i = r.extend({}, h), X.set(b, i))
          }
      }
  
      function Ia(a, b) {
          var c = b.nodeName.toLowerCase();
          "input" === c && ja.test(a.type) ? b.checked = a.checked : "input" !== c && "textarea" !== c || (b.defaultValue = a.defaultValue)
      }
  
      function Ja(a, b, c, d) {
          b = g.apply([], b);
          var e, f, h, i, j, k, l = 0,
              m = a.length,
              n = m - 1,
              q = b[0],
              s = r.isFunction(q);
          if (s || m > 1 && "string" == typeof q && !o.checkClone && Ba.test(q)) return a.each(function(e) {
              var f = a.eq(e);
              s && (b[0] = q.call(this, e, f.html())), Ja(f, b, c, d)
          });
          if (m && (e = qa(b, a[0].ownerDocument, !1, a, d), f = e.firstChild, 1 === e.childNodes.length && (e = f), f || d)) {
              for (h = r.map(na(e, "script"), Fa), i = h.length; l < m; l++) j = e, l !== n && (j = r.clone(j, !0, !0), i && r.merge(h, na(j, "script"))), c.call(a[l], j, l);
              if (i)
                  for (k = h[h.length - 1].ownerDocument, r.map(h, Ga), l = 0; l < i; l++) j = h[l], la.test(j.type || "") && !W.access(j, "globalEval") && r.contains(k, j) && (j.src ? r._evalUrl && r._evalUrl(j.src) : p(j.textContent.replace(Da, ""), k))
          }
          return a
      }
  
      function Ka(a, b, c) {
          for (var d, e = b ? r.filter(b, a) : a, f = 0; null != (d = e[f]); f++) c || 1 !== d.nodeType || r.cleanData(na(d)), d.parentNode && (c && r.contains(d.ownerDocument, d) && oa(na(d, "script")), d.parentNode.removeChild(d));
          return a
      }
      r.extend({
          htmlPrefilter: function(a) {
              return a.replace(za, "<$1></$2>")
          },
          clone: function(a, b, c) {
              var d, e, f, g, h = a.cloneNode(!0),
                  i = r.contains(a.ownerDocument, a);
              if (!(o.noCloneChecked || 1 !== a.nodeType && 11 !== a.nodeType || r.isXMLDoc(a)))
                  for (g = na(h), f = na(a), d = 0, e = f.length; d < e; d++) Ia(f[d], g[d]);
              if (b)
                  if (c)
                      for (f = f || na(a), g = g || na(h), d = 0, e = f.length; d < e; d++) Ha(f[d], g[d]);
                  else Ha(a, h);
              return g = na(h, "script"), g.length > 0 && oa(g, !i && na(a, "script")), h
          },
          cleanData: function(a) {
              for (var b, c, d, e = r.event.special, f = 0; void 0 !== (c = a[f]); f++)
                  if (U(c)) {
                      if (b = c[W.expando]) {
                          if (b.events)
                              for (d in b.events) e[d] ? r.event.remove(c, d) : r.removeEvent(c, d, b.handle);
                          c[W.expando] = void 0
                      }
                      c[X.expando] && (c[X.expando] = void 0)
                  }
          }
      }), r.fn.extend({
          detach: function(a) {
              return Ka(this, a, !0)
          },
          remove: function(a) {
              return Ka(this, a)
          },
          text: function(a) {
              return T(this, function(a) {
                  return void 0 === a ? r.text(this) : this.empty().each(function() {
                      1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType || (this.textContent = a)
                  })
              }, null, a, arguments.length)
          },
          append: function() {
              return Ja(this, arguments, function(a) {
                  if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
                      var b = Ea(this, a);
                      b.appendChild(a)
                  }
              })
          },
          prepend: function() {
              return Ja(this, arguments, function(a) {
                  if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
                      var b = Ea(this, a);
                      b.insertBefore(a, b.firstChild)
                  }
              })
          },
          before: function() {
              return Ja(this, arguments, function(a) {
                  this.parentNode && this.parentNode.insertBefore(a, this)
              })
          },
          after: function() {
              return Ja(this, arguments, function(a) {
                  this.parentNode && this.parentNode.insertBefore(a, this.nextSibling)
              })
          },
          empty: function() {
              for (var a, b = 0; null != (a = this[b]); b++) 1 === a.nodeType && (r.cleanData(na(a, !1)), a.textContent = "");
              return this
          },
          clone: function(a, b) {
              return a = null != a && a, b = null == b ? a : b, this.map(function() {
                  return r.clone(this, a, b)
              })
          },
          html: function(a) {
              return T(this, function(a) {
                  var b = this[0] || {},
                      c = 0,
                      d = this.length;
                  if (void 0 === a && 1 === b.nodeType) return b.innerHTML;
                  if ("string" == typeof a && !Aa.test(a) && !ma[(ka.exec(a) || ["", ""])[1].toLowerCase()]) {
                      a = r.htmlPrefilter(a);
                      try {
                          for (; c < d; c++) b = this[c] || {}, 1 === b.nodeType && (r.cleanData(na(b, !1)), b.innerHTML = a);
                          b = 0
                      } catch (e) {}
                  }
                  b && this.empty().append(a)
              }, null, a, arguments.length)
          },
          replaceWith: function() {
              var a = [];
              return Ja(this, arguments, function(b) {
                  var c = this.parentNode;
                  r.inArray(this, a) < 0 && (r.cleanData(na(this)), c && c.replaceChild(b, this))
              }, a)
          }
      }), r.each({
          appendTo: "append",
          prependTo: "prepend",
          insertBefore: "before",
          insertAfter: "after",
          replaceAll: "replaceWith"
      }, function(a, b) {
          r.fn[a] = function(a) {
              for (var c, d = [], e = r(a), f = e.length - 1, g = 0; g <= f; g++) c = g === f ? this : this.clone(!0), r(e[g])[b](c), h.apply(d, c.get());
              return this.pushStack(d)
          }
      });
      var La = /^margin/,
          Ma = new RegExp("^(" + aa + ")(?!px)[a-z%]+$", "i"),
          Na = function(b) {
              var c = b.ownerDocument.defaultView;
              return c && c.opener || (c = a), c.getComputedStyle(b)
          };
      ! function() {
          function b() {
              if (i) {
                  i.style.cssText = "box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%", i.innerHTML = "", ra.appendChild(h);
                  var b = a.getComputedStyle(i);
                  c = "1%" !== b.top, g = "2px" === b.marginLeft, e = "4px" === b.width, i.style.marginRight = "50%", f = "4px" === b.marginRight, ra.removeChild(h), i = null
              }
          }
          var c, e, f, g, h = d.createElement("div"),
              i = d.createElement("div");
          i.style && (i.style.backgroundClip = "content-box", i.cloneNode(!0).style.backgroundClip = "", o.clearCloneStyle = "content-box" === i.style.backgroundClip, h.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute", h.appendChild(i), r.extend(o, {
              pixelPosition: function() {
                  return b(), c
              },
              boxSizingReliable: function() {
                  return b(), e
              },
              pixelMarginRight: function() {
                  return b(), f
              },
              reliableMarginLeft: function() {
                  return b(), g
              }
          }))
      }();
  
      function Oa(a, b, c) {
          var d, e, f, g, h = a.style;
          return c = c || Na(a), c && (g = c.getPropertyValue(b) || c[b], "" !== g || r.contains(a.ownerDocument, a) || (g = r.style(a, b)), !o.pixelMarginRight() && Ma.test(g) && La.test(b) && (d = h.width, e = h.minWidth, f = h.maxWidth, h.minWidth = h.maxWidth = h.width = g, g = c.width, h.width = d, h.minWidth = e, h.maxWidth = f)), void 0 !== g ? g + "" : g
      }
  
      function Pa(a, b) {
          return {
              get: function() {
                  return a() ? void delete this.get : (this.get = b).apply(this, arguments)
              }
          }
      }
      var Qa = /^(none|table(?!-c[ea]).+)/,
          Ra = /^--/,
          Sa = {
              position: "absolute",
              visibility: "hidden",
              display: "block"
          },
          Ta = {
              letterSpacing: "0",
              fontWeight: "400"
          },
          Ua = ["Webkit", "Moz", "ms"],
          Va = d.createElement("div").style;
  
      function Wa(a) {
          if (a in Va) return a;
          var b = a[0].toUpperCase() + a.slice(1),
              c = Ua.length;
          while (c--)
              if (a = Ua[c] + b, a in Va) return a
      }
  
      function Xa(a) {
          var b = r.cssProps[a];
          return b || (b = r.cssProps[a] = Wa(a) || a), b
      }
  
      function Ya(a, b, c) {
          var d = ba.exec(b);
          return d ? Math.max(0, d[2] - (c || 0)) + (d[3] || "px") : b
      }
  
      function Za(a, b, c, d, e) {
          var f, g = 0;
          for (f = c === (d ? "border" : "content") ? 4 : "width" === b ? 1 : 0; f < 4; f += 2) "margin" === c && (g += r.css(a, c + ca[f], !0, e)), d ? ("content" === c && (g -= r.css(a, "padding" + ca[f], !0, e)), "margin" !== c && (g -= r.css(a, "border" + ca[f] + "Width", !0, e))) : (g += r.css(a, "padding" + ca[f], !0, e), "padding" !== c && (g += r.css(a, "border" + ca[f] + "Width", !0, e)));
          return g
      }
  
      function $a(a, b, c) {
          var d, e = Na(a),
              f = Oa(a, b, e),
              g = "border-box" === r.css(a, "boxSizing", !1, e);
          return Ma.test(f) ? f : (d = g && (o.boxSizingReliable() || f === a.style[b]), "auto" === f && (f = a["offset" + b[0].toUpperCase() + b.slice(1)]), f = parseFloat(f) || 0, f + Za(a, b, c || (g ? "border" : "content"), d, e) + "px")
      }
      r.extend({
          cssHooks: {
              opacity: {
                  get: function(a, b) {
                      if (b) {
                          var c = Oa(a, "opacity");
                          return "" === c ? "1" : c
                      }
                  }
              }
          },
          cssNumber: {
              animationIterationCount: !0,
              columnCount: !0,
              fillOpacity: !0,
              flexGrow: !0,
              flexShrink: !0,
              fontWeight: !0,
              lineHeight: !0,
              opacity: !0,
              order: !0,
              orphans: !0,
              widows: !0,
              zIndex: !0,
              zoom: !0
          },
          cssProps: {
              "float": "cssFloat"
          },
          style: function(a, b, c, d) {
              if (a && 3 !== a.nodeType && 8 !== a.nodeType && a.style) {
                  var e, f, g, h = r.camelCase(b),
                      i = Ra.test(b),
                      j = a.style;
                  return i || (b = Xa(h)), g = r.cssHooks[b] || r.cssHooks[h], void 0 === c ? g && "get" in g && void 0 !== (e = g.get(a, !1, d)) ? e : j[b] : (f = typeof c, "string" === f && (e = ba.exec(c)) && e[1] && (c = fa(a, b, e), f = "number"), null != c && c === c && ("number" === f && (c += e && e[3] || (r.cssNumber[h] ? "" : "px")), o.clearCloneStyle || "" !== c || 0 !== b.indexOf("background") || (j[b] = "inherit"), g && "set" in g && void 0 === (c = g.set(a, c, d)) || (i ? j.setProperty(b, c) : j[b] = c)), void 0)
              }
          },
          css: function(a, b, c, d) {
              var e, f, g, h = r.camelCase(b),
                  i = Ra.test(b);
              return i || (b = Xa(h)), g = r.cssHooks[b] || r.cssHooks[h], g && "get" in g && (e = g.get(a, !0, c)), void 0 === e && (e = Oa(a, b, d)), "normal" === e && b in Ta && (e = Ta[b]), "" === c || c ? (f = parseFloat(e), c === !0 || isFinite(f) ? f || 0 : e) : e
          }
      }), r.each(["height", "width"], function(a, b) {
          r.cssHooks[b] = {
              get: function(a, c, d) {
                  if (c) return !Qa.test(r.css(a, "display")) || a.getClientRects().length && a.getBoundingClientRect().width ? $a(a, b, d) : ea(a, Sa, function() {
                      return $a(a, b, d)
                  })
              },
              set: function(a, c, d) {
                  var e, f = d && Na(a),
                      g = d && Za(a, b, d, "border-box" === r.css(a, "boxSizing", !1, f), f);
                  return g && (e = ba.exec(c)) && "px" !== (e[3] || "px") && (a.style[b] = c, c = r.css(a, b)), Ya(a, c, g)
              }
          }
      }), r.cssHooks.marginLeft = Pa(o.reliableMarginLeft, function(a, b) {
          if (b) return (parseFloat(Oa(a, "marginLeft")) || a.getBoundingClientRect().left - ea(a, {
              marginLeft: 0
          }, function() {
              return a.getBoundingClientRect().left
          })) + "px"
      }), r.each({
          margin: "",
          padding: "",
          border: "Width"
      }, function(a, b) {
          r.cssHooks[a + b] = {
              expand: function(c) {
                  for (var d = 0, e = {}, f = "string" == typeof c ? c.split(" ") : [c]; d < 4; d++) e[a + ca[d] + b] = f[d] || f[d - 2] || f[0];
                  return e
              }
          }, La.test(a) || (r.cssHooks[a + b].set = Ya)
      }), r.fn.extend({
          css: function(a, b) {
              return T(this, function(a, b, c) {
                  var d, e, f = {},
                      g = 0;
                  if (Array.isArray(b)) {
                      for (d = Na(a), e = b.length; g < e; g++) f[b[g]] = r.css(a, b[g], !1, d);
                      return f
                  }
                  return void 0 !== c ? r.style(a, b, c) : r.css(a, b)
              }, a, b, arguments.length > 1)
          }
      });
  
      function _a(a, b, c, d, e) {
          return new _a.prototype.init(a, b, c, d, e)
      }
      r.Tween = _a, _a.prototype = {
          constructor: _a,
          init: function(a, b, c, d, e, f) {
              this.elem = a, this.prop = c, this.easing = e || r.easing._default, this.options = b, this.start = this.now = this.cur(), this.end = d, this.unit = f || (r.cssNumber[c] ? "" : "px")
          },
          cur: function() {
              var a = _a.propHooks[this.prop];
              return a && a.get ? a.get(this) : _a.propHooks._default.get(this)
          },
          run: function(a) {
              var b, c = _a.propHooks[this.prop];
              return this.options.duration ? this.pos = b = r.easing[this.easing](a, this.options.duration * a, 0, 1, this.options.duration) : this.pos = b = a, this.now = (this.end - this.start) * b + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), c && c.set ? c.set(this) : _a.propHooks._default.set(this), this
          }
      }, _a.prototype.init.prototype = _a.prototype, _a.propHooks = {
          _default: {
              get: function(a) {
                  var b;
                  return 1 !== a.elem.nodeType || null != a.elem[a.prop] && null == a.elem.style[a.prop] ? a.elem[a.prop] : (b = r.css(a.elem, a.prop, ""), b && "auto" !== b ? b : 0)
              },
              set: function(a) {
                  r.fx.step[a.prop] ? r.fx.step[a.prop](a) : 1 !== a.elem.nodeType || null == a.elem.style[r.cssProps[a.prop]] && !r.cssHooks[a.prop] ? a.elem[a.prop] = a.now : r.style(a.elem, a.prop, a.now + a.unit)
              }
          }
      }, _a.propHooks.scrollTop = _a.propHooks.scrollLeft = {
          set: function(a) {
              a.elem.nodeType && a.elem.parentNode && (a.elem[a.prop] = a.now)
          }
      }, r.easing = {
          linear: function(a) {
              return a
          },
          swing: function(a) {
              return .5 - Math.cos(a * Math.PI) / 2
          },
          _default: "swing"
      }, r.fx = _a.prototype.init, r.fx.step = {};
      var ab, bb, cb = /^(?:toggle|show|hide)$/,
          db = /queueHooks$/;
  
      function eb() {
          bb && (d.hidden === !1 && a.requestAnimationFrame ? a.requestAnimationFrame(eb) : a.setTimeout(eb, r.fx.interval), r.fx.tick())
      }
  
      function fb() {
          return a.setTimeout(function() {
              ab = void 0
          }), ab = r.now()
      }
  
      function gb(a, b) {
          var c, d = 0,
              e = {
                  height: a
              };
          for (b = b ? 1 : 0; d < 4; d += 2 - b) c = ca[d], e["margin" + c] = e["padding" + c] = a;
          return b && (e.opacity = e.width = a), e
      }
  
      function hb(a, b, c) {
          for (var d, e = (kb.tweeners[b] || []).concat(kb.tweeners["*"]), f = 0, g = e.length; f < g; f++)
              if (d = e[f].call(c, b, a)) return d
      }
  
      function ib(a, b, c) {
          var d, e, f, g, h, i, j, k, l = "width" in b || "height" in b,
              m = this,
              n = {},
              o = a.style,
              p = a.nodeType && da(a),
              q = W.get(a, "fxshow");
          c.queue || (g = r._queueHooks(a, "fx"), null == g.unqueued && (g.unqueued = 0, h = g.empty.fire, g.empty.fire = function() {
              g.unqueued || h()
          }), g.unqueued++, m.always(function() {
              m.always(function() {
                  g.unqueued--, r.queue(a, "fx").length || g.empty.fire()
              })
          }));
          for (d in b)
              if (e = b[d], cb.test(e)) {
                  if (delete b[d], f = f || "toggle" === e, e === (p ? "hide" : "show")) {
                      if ("show" !== e || !q || void 0 === q[d]) continue;
                      p = !0
                  }
                  n[d] = q && q[d] || r.style(a, d)
              }
          if (i = !r.isEmptyObject(b), i || !r.isEmptyObject(n)) {
              l && 1 === a.nodeType && (c.overflow = [o.overflow, o.overflowX, o.overflowY], j = q && q.display, null == j && (j = W.get(a, "display")), k = r.css(a, "display"), "none" === k && (j ? k = j : (ia([a], !0), j = a.style.display || j, k = r.css(a, "display"), ia([a]))), ("inline" === k || "inline-block" === k && null != j) && "none" === r.css(a, "float") && (i || (m.done(function() {
                  o.display = j
              }), null == j && (k = o.display, j = "none" === k ? "" : k)), o.display = "inline-block")), c.overflow && (o.overflow = "hidden", m.always(function() {
                  o.overflow = c.overflow[0], o.overflowX = c.overflow[1], o.overflowY = c.overflow[2]
              })), i = !1;
              for (d in n) i || (q ? "hidden" in q && (p = q.hidden) : q = W.access(a, "fxshow", {
                  display: j
              }), f && (q.hidden = !p), p && ia([a], !0), m.done(function() {
                  p || ia([a]), W.remove(a, "fxshow");
                  for (d in n) r.style(a, d, n[d])
              })), i = hb(p ? q[d] : 0, d, m), d in q || (q[d] = i.start, p && (i.end = i.start, i.start = 0))
          }
      }
  
      function jb(a, b) {
          var c, d, e, f, g;
          for (c in a)
              if (d = r.camelCase(c), e = b[d], f = a[c], Array.isArray(f) && (e = f[1], f = a[c] = f[0]), c !== d && (a[d] = f, delete a[c]), g = r.cssHooks[d], g && "expand" in g) {
                  f = g.expand(f), delete a[d];
                  for (c in f) c in a || (a[c] = f[c], b[c] = e)
              } else b[d] = e
      }
  
      function kb(a, b, c) {
          var d, e, f = 0,
              g = kb.prefilters.length,
              h = r.Deferred().always(function() {
                  delete i.elem
              }),
              i = function() {
                  if (e) return !1;
                  for (var b = ab || fb(), c = Math.max(0, j.startTime + j.duration - b), d = c / j.duration || 0, f = 1 - d, g = 0, i = j.tweens.length; g < i; g++) j.tweens[g].run(f);
                  return h.notifyWith(a, [j, f, c]), f < 1 && i ? c : (i || h.notifyWith(a, [j, 1, 0]), h.resolveWith(a, [j]), !1)
              },
              j = h.promise({
                  elem: a,
                  props: r.extend({}, b),
                  opts: r.extend(!0, {
                      specialEasing: {},
                      easing: r.easing._default
                  }, c),
                  originalProperties: b,
                  originalOptions: c,
                  startTime: ab || fb(),
                  duration: c.duration,
                  tweens: [],
                  createTween: function(b, c) {
                      var d = r.Tween(a, j.opts, b, c, j.opts.specialEasing[b] || j.opts.easing);
                      return j.tweens.push(d), d
                  },
                  stop: function(b) {
                      var c = 0,
                          d = b ? j.tweens.length : 0;
                      if (e) return this;
                      for (e = !0; c < d; c++) j.tweens[c].run(1);
                      return b ? (h.notifyWith(a, [j, 1, 0]), h.resolveWith(a, [j, b])) : h.rejectWith(a, [j, b]), this
                  }
              }),
              k = j.props;
          for (jb(k, j.opts.specialEasing); f < g; f++)
              if (d = kb.prefilters[f].call(j, a, k, j.opts)) return r.isFunction(d.stop) && (r._queueHooks(j.elem, j.opts.queue).stop = r.proxy(d.stop, d)), d;
          return r.map(k, hb, j), r.isFunction(j.opts.start) && j.opts.start.call(a, j), j.progress(j.opts.progress).done(j.opts.done, j.opts.complete).fail(j.opts.fail).always(j.opts.always), r.fx.timer(r.extend(i, {
              elem: a,
              anim: j,
              queue: j.opts.queue
          })), j
      }
      r.Animation = r.extend(kb, {
              tweeners: {
                  "*": [function(a, b) {
                      var c = this.createTween(a, b);
                      return fa(c.elem, a, ba.exec(b), c), c
                  }]
              },
              tweener: function(a, b) {
                  r.isFunction(a) ? (b = a, a = ["*"]) : a = a.match(L);
                  for (var c, d = 0, e = a.length; d < e; d++) c = a[d], kb.tweeners[c] = kb.tweeners[c] || [], kb.tweeners[c].unshift(b)
              },
              prefilters: [ib],
              prefilter: function(a, b) {
                  b ? kb.prefilters.unshift(a) : kb.prefilters.push(a)
              }
          }), r.speed = function(a, b, c) {
              var d = a && "object" == typeof a ? r.extend({}, a) : {
                  complete: c || !c && b || r.isFunction(a) && a,
                  duration: a,
                  easing: c && b || b && !r.isFunction(b) && b
              };
              return r.fx.off ? d.duration = 0 : "number" != typeof d.duration && (d.duration in r.fx.speeds ? d.duration = r.fx.speeds[d.duration] : d.duration = r.fx.speeds._default), null != d.queue && d.queue !== !0 || (d.queue = "fx"), d.old = d.complete, d.complete = function() {
                  r.isFunction(d.old) && d.old.call(this), d.queue && r.dequeue(this, d.queue)
              }, d
          }, r.fn.extend({
              fadeTo: function(a, b, c, d) {
                  return this.filter(da).css("opacity", 0).show().end().animate({
                      opacity: b
                  }, a, c, d)
              },
              animate: function(a, b, c, d) {
                  var e = r.isEmptyObject(a),
                      f = r.speed(b, c, d),
                      g = function() {
                          var b = kb(this, r.extend({}, a), f);
                          (e || W.get(this, "finish")) && b.stop(!0)
                      };
                  return g.finish = g, e || f.queue === !1 ? this.each(g) : this.queue(f.queue, g)
              },
              stop: function(a, b, c) {
                  var d = function(a) {
                      var b = a.stop;
                      delete a.stop, b(c)
                  };
                  return "string" != typeof a && (c = b, b = a, a = void 0), b && a !== !1 && this.queue(a || "fx", []), this.each(function() {
                      var b = !0,
                          e = null != a && a + "queueHooks",
                          f = r.timers,
                          g = W.get(this);
                      if (e) g[e] && g[e].stop && d(g[e]);
                      else
                          for (e in g) g[e] && g[e].stop && db.test(e) && d(g[e]);
                      for (e = f.length; e--;) f[e].elem !== this || null != a && f[e].queue !== a || (f[e].anim.stop(c), b = !1, f.splice(e, 1));
                      !b && c || r.dequeue(this, a)
                  })
              },
              finish: function(a) {
                  return a !== !1 && (a = a || "fx"), this.each(function() {
                      var b, c = W.get(this),
                          d = c[a + "queue"],
                          e = c[a + "queueHooks"],
                          f = r.timers,
                          g = d ? d.length : 0;
                      for (c.finish = !0, r.queue(this, a, []), e && e.stop && e.stop.call(this, !0), b = f.length; b--;) f[b].elem === this && f[b].queue === a && (f[b].anim.stop(!0), f.splice(b, 1));
                      for (b = 0; b < g; b++) d[b] && d[b].finish && d[b].finish.call(this);
                      delete c.finish
                  })
              }
          }), r.each(["toggle", "show", "hide"], function(a, b) {
              var c = r.fn[b];
              r.fn[b] = function(a, d, e) {
                  return null == a || "boolean" == typeof a ? c.apply(this, arguments) : this.animate(gb(b, !0), a, d, e)
              }
          }), r.each({
              slideDown: gb("show"),
              slideUp: gb("hide"),
              slideToggle: gb("toggle"),
              fadeIn: {
                  opacity: "show"
              },
              fadeOut: {
                  opacity: "hide"
              },
              fadeToggle: {
                  opacity: "toggle"
              }
          }, function(a, b) {
              r.fn[a] = function(a, c, d) {
                  return this.animate(b, a, c, d)
              }
          }), r.timers = [], r.fx.tick = function() {
              var a, b = 0,
                  c = r.timers;
              for (ab = r.now(); b < c.length; b++) a = c[b], a() || c[b] !== a || c.splice(b--, 1);
              c.length || r.fx.stop(), ab = void 0
          }, r.fx.timer = function(a) {
              r.timers.push(a), r.fx.start()
          }, r.fx.interval = 13, r.fx.start = function() {
              bb || (bb = !0, eb())
          }, r.fx.stop = function() {
              bb = null
          }, r.fx.speeds = {
              slow: 600,
              fast: 200,
              _default: 400
          }, r.fn.delay = function(b, c) {
              return b = r.fx ? r.fx.speeds[b] || b : b, c = c || "fx", this.queue(c, function(c, d) {
                  var e = a.setTimeout(c, b);
                  d.stop = function() {
                      a.clearTimeout(e)
                  }
              })
          },
          function() {
              var a = d.createElement("input"),
                  b = d.createElement("select"),
                  c = b.appendChild(d.createElement("option"));
              a.type = "checkbox", o.checkOn = "" !== a.value, o.optSelected = c.selected, a = d.createElement("input"), a.value = "t", a.type = "radio", o.radioValue = "t" === a.value
          }();
      var lb, mb = r.expr.attrHandle;
      r.fn.extend({
          attr: function(a, b) {
              return T(this, r.attr, a, b, arguments.length > 1)
          },
          removeAttr: function(a) {
              return this.each(function() {
                  r.removeAttr(this, a)
              })
          }
      }), r.extend({
          attr: function(a, b, c) {
              var d, e, f = a.nodeType;
              if (3 !== f && 8 !== f && 2 !== f) return "undefined" == typeof a.getAttribute ? r.prop(a, b, c) : (1 === f && r.isXMLDoc(a) || (e = r.attrHooks[b.toLowerCase()] || (r.expr.match.bool.test(b) ? lb : void 0)), void 0 !== c ? null === c ? void r.removeAttr(a, b) : e && "set" in e && void 0 !== (d = e.set(a, c, b)) ? d : (a.setAttribute(b, c + ""), c) : e && "get" in e && null !== (d = e.get(a, b)) ? d : (d = r.find.attr(a, b),
                  null == d ? void 0 : d))
          },
          attrHooks: {
              type: {
                  set: function(a, b) {
                      if (!o.radioValue && "radio" === b && B(a, "input")) {
                          var c = a.value;
                          return a.setAttribute("type", b), c && (a.value = c), b
                      }
                  }
              }
          },
          removeAttr: function(a, b) {
              var c, d = 0,
                  e = b && b.match(L);
              if (e && 1 === a.nodeType)
                  while (c = e[d++]) a.removeAttribute(c)
          }
      }), lb = {
          set: function(a, b, c) {
              return b === !1 ? r.removeAttr(a, c) : a.setAttribute(c, c), c
          }
      }, r.each(r.expr.match.bool.source.match(/\w+/g), function(a, b) {
          var c = mb[b] || r.find.attr;
          mb[b] = function(a, b, d) {
              var e, f, g = b.toLowerCase();
              return d || (f = mb[g], mb[g] = e, e = null != c(a, b, d) ? g : null, mb[g] = f), e
          }
      });
      var nb = /^(?:input|select|textarea|button)$/i,
          ob = /^(?:a|area)$/i;
      r.fn.extend({
          prop: function(a, b) {
              return T(this, r.prop, a, b, arguments.length > 1)
          },
          removeProp: function(a) {
              return this.each(function() {
                  delete this[r.propFix[a] || a]
              })
          }
      }), r.extend({
          prop: function(a, b, c) {
              var d, e, f = a.nodeType;
              if (3 !== f && 8 !== f && 2 !== f) return 1 === f && r.isXMLDoc(a) || (b = r.propFix[b] || b, e = r.propHooks[b]), void 0 !== c ? e && "set" in e && void 0 !== (d = e.set(a, c, b)) ? d : a[b] = c : e && "get" in e && null !== (d = e.get(a, b)) ? d : a[b]
          },
          propHooks: {
              tabIndex: {
                  get: function(a) {
                      var b = r.find.attr(a, "tabindex");
                      return b ? parseInt(b, 10) : nb.test(a.nodeName) || ob.test(a.nodeName) && a.href ? 0 : -1
                  }
              }
          },
          propFix: {
              "for": "htmlFor",
              "class": "className"
          }
      }), o.optSelected || (r.propHooks.selected = {
          get: function(a) {
              var b = a.parentNode;
              return b && b.parentNode && b.parentNode.selectedIndex, null
          },
          set: function(a) {
              var b = a.parentNode;
              b && (b.selectedIndex, b.parentNode && b.parentNode.selectedIndex)
          }
      }), r.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
          r.propFix[this.toLowerCase()] = this
      });
  
      function pb(a) {
          var b = a.match(L) || [];
          return b.join(" ")
      }
  
      function qb(a) {
          return a.getAttribute && a.getAttribute("class") || ""
      }
      r.fn.extend({
          addClass: function(a) {
              var b, c, d, e, f, g, h, i = 0;
              if (r.isFunction(a)) return this.each(function(b) {
                  r(this).addClass(a.call(this, b, qb(this)))
              });
              if ("string" == typeof a && a) {
                  b = a.match(L) || [];
                  while (c = this[i++])
                      if (e = qb(c), d = 1 === c.nodeType && " " + pb(e) + " ") {
                          g = 0;
                          while (f = b[g++]) d.indexOf(" " + f + " ") < 0 && (d += f + " ");
                          h = pb(d), e !== h && c.setAttribute("class", h)
                      }
              }
              return this
          },
          removeClass: function(a) {
              var b, c, d, e, f, g, h, i = 0;
              if (r.isFunction(a)) return this.each(function(b) {
                  r(this).removeClass(a.call(this, b, qb(this)))
              });
              if (!arguments.length) return this.attr("class", "");
              if ("string" == typeof a && a) {
                  b = a.match(L) || [];
                  while (c = this[i++])
                      if (e = qb(c), d = 1 === c.nodeType && " " + pb(e) + " ") {
                          g = 0;
                          while (f = b[g++])
                              while (d.indexOf(" " + f + " ") > -1) d = d.replace(" " + f + " ", " ");
                          h = pb(d), e !== h && c.setAttribute("class", h)
                      }
              }
              return this
          },
          toggleClass: function(a, b) {
              var c = typeof a;
              return "boolean" == typeof b && "string" === c ? b ? this.addClass(a) : this.removeClass(a) : r.isFunction(a) ? this.each(function(c) {
                  r(this).toggleClass(a.call(this, c, qb(this), b), b)
              }) : this.each(function() {
                  var b, d, e, f;
                  if ("string" === c) {
                      d = 0, e = r(this), f = a.match(L) || [];
                      while (b = f[d++]) e.hasClass(b) ? e.removeClass(b) : e.addClass(b)
                  } else void 0 !== a && "boolean" !== c || (b = qb(this), b && W.set(this, "__className__", b), this.setAttribute && this.setAttribute("class", b || a === !1 ? "" : W.get(this, "__className__") || ""))
              })
          },
          hasClass: function(a) {
              var b, c, d = 0;
              b = " " + a + " ";
              while (c = this[d++])
                  if (1 === c.nodeType && (" " + pb(qb(c)) + " ").indexOf(b) > -1) return !0;
              return !1
          }
      });
      var rb = /\r/g;
      r.fn.extend({
          val: function(a) {
              var b, c, d, e = this[0]; {
                  if (arguments.length) return d = r.isFunction(a), this.each(function(c) {
                      var e;
                      1 === this.nodeType && (e = d ? a.call(this, c, r(this).val()) : a, null == e ? e = "" : "number" == typeof e ? e += "" : Array.isArray(e) && (e = r.map(e, function(a) {
                          return null == a ? "" : a + ""
                      })), b = r.valHooks[this.type] || r.valHooks[this.nodeName.toLowerCase()], b && "set" in b && void 0 !== b.set(this, e, "value") || (this.value = e))
                  });
                  if (e) return b = r.valHooks[e.type] || r.valHooks[e.nodeName.toLowerCase()], b && "get" in b && void 0 !== (c = b.get(e, "value")) ? c : (c = e.value, "string" == typeof c ? c.replace(rb, "") : null == c ? "" : c)
              }
          }
      }), r.extend({
          valHooks: {
              option: {
                  get: function(a) {
                      var b = r.find.attr(a, "value");
                      return null != b ? b : pb(r.text(a))
                  }
              },
              select: {
                  get: function(a) {
                      var b, c, d, e = a.options,
                          f = a.selectedIndex,
                          g = "select-one" === a.type,
                          h = g ? null : [],
                          i = g ? f + 1 : e.length;
                      for (d = f < 0 ? i : g ? f : 0; d < i; d++)
                          if (c = e[d], (c.selected || d === f) && !c.disabled && (!c.parentNode.disabled || !B(c.parentNode, "optgroup"))) {
                              if (b = r(c).val(), g) return b;
                              h.push(b)
                          }
                      return h
                  },
                  set: function(a, b) {
                      var c, d, e = a.options,
                          f = r.makeArray(b),
                          g = e.length;
                      while (g--) d = e[g], (d.selected = r.inArray(r.valHooks.option.get(d), f) > -1) && (c = !0);
                      return c || (a.selectedIndex = -1), f
                  }
              }
          }
      }), r.each(["radio", "checkbox"], function() {
          r.valHooks[this] = {
              set: function(a, b) {
                  if (Array.isArray(b)) return a.checked = r.inArray(r(a).val(), b) > -1
              }
          }, o.checkOn || (r.valHooks[this].get = function(a) {
              return null === a.getAttribute("value") ? "on" : a.value
          })
      });
      var sb = /^(?:focusinfocus|focusoutblur)$/;
      r.extend(r.event, {
          trigger: function(b, c, e, f) {
              var g, h, i, j, k, m, n, o = [e || d],
                  p = l.call(b, "type") ? b.type : b,
                  q = l.call(b, "namespace") ? b.namespace.split(".") : [];
              if (h = i = e = e || d, 3 !== e.nodeType && 8 !== e.nodeType && !sb.test(p + r.event.triggered) && (p.indexOf(".") > -1 && (q = p.split("."), p = q.shift(), q.sort()), k = p.indexOf(":") < 0 && "on" + p, b = b[r.expando] ? b : new r.Event(p, "object" == typeof b && b), b.isTrigger = f ? 2 : 3, b.namespace = q.join("."), b.rnamespace = b.namespace ? new RegExp("(^|\\.)" + q.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, b.result = void 0, b.target || (b.target = e), c = null == c ? [b] : r.makeArray(c, [b]), n = r.event.special[p] || {}, f || !n.trigger || n.trigger.apply(e, c) !== !1)) {
                  if (!f && !n.noBubble && !r.isWindow(e)) {
                      for (j = n.delegateType || p, sb.test(j + p) || (h = h.parentNode); h; h = h.parentNode) o.push(h), i = h;
                      i === (e.ownerDocument || d) && o.push(i.defaultView || i.parentWindow || a)
                  }
                  g = 0;
                  while ((h = o[g++]) && !b.isPropagationStopped()) b.type = g > 1 ? j : n.bindType || p, m = (W.get(h, "events") || {})[b.type] && W.get(h, "handle"), m && m.apply(h, c), m = k && h[k], m && m.apply && U(h) && (b.result = m.apply(h, c), b.result === !1 && b.preventDefault());
                  return b.type = p, f || b.isDefaultPrevented() || n._default && n._default.apply(o.pop(), c) !== !1 || !U(e) || k && r.isFunction(e[p]) && !r.isWindow(e) && (i = e[k], i && (e[k] = null), r.event.triggered = p, e[p](), r.event.triggered = void 0, i && (e[k] = i)), b.result
              }
          },
          simulate: function(a, b, c) {
              var d = r.extend(new r.Event, c, {
                  type: a,
                  isSimulated: !0
              });
              r.event.trigger(d, null, b)
          }
      }), r.fn.extend({
          trigger: function(a, b) {
              return this.each(function() {
                  r.event.trigger(a, b, this)
              })
          },
          triggerHandler: function(a, b) {
              var c = this[0];
              if (c) return r.event.trigger(a, b, c, !0)
          }
      }), r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "), function(a, b) {
          r.fn[b] = function(a, c) {
              return arguments.length > 0 ? this.on(b, null, a, c) : this.trigger(b)
          }
      }), r.fn.extend({
          hover: function(a, b) {
              return this.mouseenter(a).mouseleave(b || a)
          }
      }), o.focusin = "onfocusin" in a, o.focusin || r.each({
          focus: "focusin",
          blur: "focusout"
      }, function(a, b) {
          var c = function(a) {
              r.event.simulate(b, a.target, r.event.fix(a))
          };
          r.event.special[b] = {
              setup: function() {
                  var d = this.ownerDocument || this,
                      e = W.access(d, b);
                  e || d.addEventListener(a, c, !0), W.access(d, b, (e || 0) + 1)
              },
              teardown: function() {
                  var d = this.ownerDocument || this,
                      e = W.access(d, b) - 1;
                  e ? W.access(d, b, e) : (d.removeEventListener(a, c, !0), W.remove(d, b))
              }
          }
      });
      var tb = a.location,
          ub = r.now(),
          vb = /\?/;
      r.parseXML = function(b) {
          var c;
          if (!b || "string" != typeof b) return null;
          try {
              c = (new a.DOMParser).parseFromString(b, "text/xml")
          } catch (d) {
              c = void 0
          }
          return c && !c.getElementsByTagName("parsererror").length || r.error("Invalid XML: " + b), c
      };
      var wb = /\[\]$/,
          xb = /\r?\n/g,
          yb = /^(?:submit|button|image|reset|file)$/i,
          zb = /^(?:input|select|textarea|keygen)/i;
  
      function Ab(a, b, c, d) {
          var e;
          if (Array.isArray(b)) r.each(b, function(b, e) {
              c || wb.test(a) ? d(a, e) : Ab(a + "[" + ("object" == typeof e && null != e ? b : "") + "]", e, c, d)
          });
          else if (c || "object" !== r.type(b)) d(a, b);
          else
              for (e in b) Ab(a + "[" + e + "]", b[e], c, d)
      }
      r.param = function(a, b) {
          var c, d = [],
              e = function(a, b) {
                  var c = r.isFunction(b) ? b() : b;
                  d[d.length] = encodeURIComponent(a) + "=" + encodeURIComponent(null == c ? "" : c)
              };
          if (Array.isArray(a) || a.jquery && !r.isPlainObject(a)) r.each(a, function() {
              e(this.name, this.value)
          });
          else
              for (c in a) Ab(c, a[c], b, e);
          return d.join("&")
      }, r.fn.extend({
          serialize: function() {
              return r.param(this.serializeArray())
          },
          serializeArray: function() {
              return this.map(function() {
                  var a = r.prop(this, "elements");
                  return a ? r.makeArray(a) : this
              }).filter(function() {
                  var a = this.type;
                  return this.name && !r(this).is(":disabled") && zb.test(this.nodeName) && !yb.test(a) && (this.checked || !ja.test(a))
              }).map(function(a, b) {
                  var c = r(this).val();
                  return null == c ? null : Array.isArray(c) ? r.map(c, function(a) {
                      return {
                          name: b.name,
                          value: a.replace(xb, "\r\n")
                      }
                  }) : {
                      name: b.name,
                      value: c.replace(xb, "\r\n")
                  }
              }).get()
          }
      });
      var Bb = /%20/g,
          Cb = /#.*$/,
          Db = /([?&])_=[^&]*/,
          Eb = /^(.*?):[ \t]*([^\r\n]*)$/gm,
          Fb = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
          Gb = /^(?:GET|HEAD)$/,
          Hb = /^\/\//,
          Ib = {},
          Jb = {},
          Kb = "*/".concat("*"),
          Lb = d.createElement("a");
      Lb.href = tb.href;
  
      function Mb(a) {
          return function(b, c) {
              "string" != typeof b && (c = b, b = "*");
              var d, e = 0,
                  f = b.toLowerCase().match(L) || [];
              if (r.isFunction(c))
                  while (d = f[e++]) "+" === d[0] ? (d = d.slice(1) || "*", (a[d] = a[d] || []).unshift(c)) : (a[d] = a[d] || []).push(c)
          }
      }
  
      function Nb(a, b, c, d) {
          var e = {},
              f = a === Jb;
  
          function g(h) {
              var i;
              return e[h] = !0, r.each(a[h] || [], function(a, h) {
                  var j = h(b, c, d);
                  return "string" != typeof j || f || e[j] ? f ? !(i = j) : void 0 : (b.dataTypes.unshift(j), g(j), !1)
              }), i
          }
          return g(b.dataTypes[0]) || !e["*"] && g("*")
      }
  
      function Ob(a, b) {
          var c, d, e = r.ajaxSettings.flatOptions || {};
          for (c in b) void 0 !== b[c] && ((e[c] ? a : d || (d = {}))[c] = b[c]);
          return d && r.extend(!0, a, d), a
      }
  
      function Pb(a, b, c) {
          var d, e, f, g, h = a.contents,
              i = a.dataTypes;
          while ("*" === i[0]) i.shift(), void 0 === d && (d = a.mimeType || b.getResponseHeader("Content-Type"));
          if (d)
              for (e in h)
                  if (h[e] && h[e].test(d)) {
                      i.unshift(e);
                      break
                  }
          if (i[0] in c) f = i[0];
          else {
              for (e in c) {
                  if (!i[0] || a.converters[e + " " + i[0]]) {
                      f = e;
                      break
                  }
                  g || (g = e)
              }
              f = f || g
          }
          if (f) return f !== i[0] && i.unshift(f), c[f]
      }
  
      function Qb(a, b, c, d) {
          var e, f, g, h, i, j = {},
              k = a.dataTypes.slice();
          if (k[1])
              for (g in a.converters) j[g.toLowerCase()] = a.converters[g];
          f = k.shift();
          while (f)
              if (a.responseFields[f] && (c[a.responseFields[f]] = b), !i && d && a.dataFilter && (b = a.dataFilter(b, a.dataType)), i = f, f = k.shift())
                  if ("*" === f) f = i;
                  else if ("*" !== i && i !== f) {
              if (g = j[i + " " + f] || j["* " + f], !g)
                  for (e in j)
                      if (h = e.split(" "), h[1] === f && (g = j[i + " " + h[0]] || j["* " + h[0]])) {
                          g === !0 ? g = j[e] : j[e] !== !0 && (f = h[0], k.unshift(h[1]));
                          break
                      }
              if (g !== !0)
                  if (g && a["throws"]) b = g(b);
                  else try {
                      b = g(b)
                  } catch (l) {
                      return {
                          state: "parsererror",
                          error: g ? l : "No conversion from " + i + " to " + f
                      }
                  }
          }
          return {
              state: "success",
              data: b
          }
      }
      r.extend({
          active: 0,
          lastModified: {},
          etag: {},
          ajaxSettings: {
              url: tb.href,
              type: "GET",
              isLocal: Fb.test(tb.protocol),
              global: !0,
              processData: !0,
              async: !0,
              contentType: "application/x-www-form-urlencoded; charset=UTF-8",
              accepts: {
                  "*": Kb,
                  text: "text/plain",
                  html: "text/html",
                  xml: "application/xml, text/xml",
                  json: "application/json, text/javascript"
              },
              contents: {
                  xml: /\bxml\b/,
                  html: /\bhtml/,
                  json: /\bjson\b/
              },
              responseFields: {
                  xml: "responseXML",
                  text: "responseText",
                  json: "responseJSON"
              },
              converters: {
                  "* text": String,
                  "text html": !0,
                  "text json": JSON.parse,
                  "text xml": r.parseXML
              },
              flatOptions: {
                  url: !0,
                  context: !0
              }
          },
          ajaxSetup: function(a, b) {
              return b ? Ob(Ob(a, r.ajaxSettings), b) : Ob(r.ajaxSettings, a)
          },
          ajaxPrefilter: Mb(Ib),
          ajaxTransport: Mb(Jb),
          ajax: function(b, c) {
              "object" == typeof b && (c = b, b = void 0), c = c || {};
              var e, f, g, h, i, j, k, l, m, n, o = r.ajaxSetup({}, c),
                  p = o.context || o,
                  q = o.context && (p.nodeType || p.jquery) ? r(p) : r.event,
                  s = r.Deferred(),
                  t = r.Callbacks("once memory"),
                  u = o.statusCode || {},
                  v = {},
                  w = {},
                  x = "canceled",
                  y = {
                      readyState: 0,
                      getResponseHeader: function(a) {
                          var b;
                          if (k) {
                              if (!h) {
                                  h = {};
                                  while (b = Eb.exec(g)) h[b[1].toLowerCase()] = b[2]
                              }
                              b = h[a.toLowerCase()]
                          }
                          return null == b ? null : b
                      },
                      getAllResponseHeaders: function() {
                          return k ? g : null
                      },
                      setRequestHeader: function(a, b) {
                          return null == k && (a = w[a.toLowerCase()] = w[a.toLowerCase()] || a, v[a] = b), this
                      },
                      overrideMimeType: function(a) {
                          return null == k && (o.mimeType = a), this
                      },
                      statusCode: function(a) {
                          var b;
                          if (a)
                              if (k) y.always(a[y.status]);
                              else
                                  for (b in a) u[b] = [u[b], a[b]];
                          return this
                      },
                      abort: function(a) {
                          var b = a || x;
                          return e && e.abort(b), A(0, b), this
                      }
                  };
              if (s.promise(y), o.url = ((b || o.url || tb.href) + "").replace(Hb, tb.protocol + "//"), o.type = c.method || c.type || o.method || o.type, o.dataTypes = (o.dataType || "*").toLowerCase().match(L) || [""], null == o.crossDomain) {
                  j = d.createElement("a");
                  try {
                      j.href = o.url, j.href = j.href, o.crossDomain = Lb.protocol + "//" + Lb.host != j.protocol + "//" + j.host
                  } catch (z) {
                      o.crossDomain = !0
                  }
              }
              if (o.data && o.processData && "string" != typeof o.data && (o.data = r.param(o.data, o.traditional)), Nb(Ib, o, c, y), k) return y;
              l = r.event && o.global, l && 0 === r.active++ && r.event.trigger("ajaxStart"), o.type = o.type.toUpperCase(), o.hasContent = !Gb.test(o.type), f = o.url.replace(Cb, ""), o.hasContent ? o.data && o.processData && 0 === (o.contentType || "").indexOf("application/x-www-form-urlencoded") && (o.data = o.data.replace(Bb, "+")) : (n = o.url.slice(f.length), o.data && (f += (vb.test(f) ? "&" : "?") + o.data, delete o.data), o.cache === !1 && (f = f.replace(Db, "$1"), n = (vb.test(f) ? "&" : "?") + "_=" + ub++ + n), o.url = f + n), o.ifModified && (r.lastModified[f] && y.setRequestHeader("If-Modified-Since", r.lastModified[f]), r.etag[f] && y.setRequestHeader("If-None-Match", r.etag[f])), (o.data && o.hasContent && o.contentType !== !1 || c.contentType) && y.setRequestHeader("Content-Type", o.contentType), y.setRequestHeader("Accept", o.dataTypes[0] && o.accepts[o.dataTypes[0]] ? o.accepts[o.dataTypes[0]] + ("*" !== o.dataTypes[0] ? ", " + Kb + "; q=0.01" : "") : o.accepts["*"]);
              for (m in o.headers) y.setRequestHeader(m, o.headers[m]);
              if (o.beforeSend && (o.beforeSend.call(p, y, o) === !1 || k)) return y.abort();
              if (x = "abort", t.add(o.complete), y.done(o.success), y.fail(o.error), e = Nb(Jb, o, c, y)) {
                  if (y.readyState = 1, l && q.trigger("ajaxSend", [y, o]), k) return y;
                  o.async && o.timeout > 0 && (i = a.setTimeout(function() {
                      y.abort("timeout")
                  }, o.timeout));
                  try {
                      k = !1, e.send(v, A)
                  } catch (z) {
                      if (k) throw z;
                      A(-1, z)
                  }
              } else A(-1, "No Transport");
  
              function A(b, c, d, h) {
                  var j, m, n, v, w, x = c;
                  k || (k = !0, i && a.clearTimeout(i), e = void 0, g = h || "", y.readyState = b > 0 ? 4 : 0, j = b >= 200 && b < 300 || 304 === b, d && (v = Pb(o, y, d)), v = Qb(o, v, y, j), j ? (o.ifModified && (w = y.getResponseHeader("Last-Modified"), w && (r.lastModified[f] = w), w = y.getResponseHeader("etag"), w && (r.etag[f] = w)), 204 === b || "HEAD" === o.type ? x = "nocontent" : 304 === b ? x = "notmodified" : (x = v.state, m = v.data, n = v.error, j = !n)) : (n = x, !b && x || (x = "error", b < 0 && (b = 0))), y.status = b, y.statusText = (c || x) + "", j ? s.resolveWith(p, [m, x, y]) : s.rejectWith(p, [y, x, n]), y.statusCode(u), u = void 0, l && q.trigger(j ? "ajaxSuccess" : "ajaxError", [y, o, j ? m : n]), t.fireWith(p, [y, x]), l && (q.trigger("ajaxComplete", [y, o]), --r.active || r.event.trigger("ajaxStop")))
              }
              return y
          },
          getJSON: function(a, b, c) {
              return r.get(a, b, c, "json")
          },
          getScript: function(a, b) {
              return r.get(a, void 0, b, "script")
          }
      }), r.each(["get", "post"], function(a, b) {
          r[b] = function(a, c, d, e) {
              return r.isFunction(c) && (e = e || d, d = c, c = void 0), r.ajax(r.extend({
                  url: a,
                  type: b,
                  dataType: e,
                  data: c,
                  success: d
              }, r.isPlainObject(a) && a))
          }
      }), r._evalUrl = function(a) {
          return r.ajax({
              url: a,
              type: "GET",
              dataType: "script",
              cache: !0,
              async: !1,
              global: !1,
              "throws": !0
          })
      }, r.fn.extend({
          wrapAll: function(a) {
              var b;
              return this[0] && (r.isFunction(a) && (a = a.call(this[0])), b = r(a, this[0].ownerDocument).eq(0).clone(!0), this[0].parentNode && b.insertBefore(this[0]), b.map(function() {
                  var a = this;
                  while (a.firstElementChild) a = a.firstElementChild;
                  return a
              }).append(this)), this
          },
          wrapInner: function(a) {
              return r.isFunction(a) ? this.each(function(b) {
                  r(this).wrapInner(a.call(this, b))
              }) : this.each(function() {
                  var b = r(this),
                      c = b.contents();
                  c.length ? c.wrapAll(a) : b.append(a)
              })
          },
          wrap: function(a) {
              var b = r.isFunction(a);
              return this.each(function(c) {
                  r(this).wrapAll(b ? a.call(this, c) : a)
              })
          },
          unwrap: function(a) {
              return this.parent(a).not("body").each(function() {
                  r(this).replaceWith(this.childNodes)
              }), this
          }
      }), r.expr.pseudos.hidden = function(a) {
          return !r.expr.pseudos.visible(a)
      }, r.expr.pseudos.visible = function(a) {
          return !!(a.offsetWidth || a.offsetHeight || a.getClientRects().length)
      }, r.ajaxSettings.xhr = function() {
          try {
              return new a.XMLHttpRequest
          } catch (b) {}
      };
      var Rb = {
              0: 200,
              1223: 204
          },
          Sb = r.ajaxSettings.xhr();
      o.cors = !!Sb && "withCredentials" in Sb, o.ajax = Sb = !!Sb, r.ajaxTransport(function(b) {
          var c, d;
          if (o.cors || Sb && !b.crossDomain) return {
              send: function(e, f) {
                  var g, h = b.xhr();
                  if (h.open(b.type, b.url, b.async, b.username, b.password), b.xhrFields)
                      for (g in b.xhrFields) h[g] = b.xhrFields[g];
                  b.mimeType && h.overrideMimeType && h.overrideMimeType(b.mimeType), b.crossDomain || e["X-Requested-With"] || (e["X-Requested-With"] = "XMLHttpRequest");
                  for (g in e) h.setRequestHeader(g, e[g]);
                  c = function(a) {
                      return function() {
                          c && (c = d = h.onload = h.onerror = h.onabort = h.onreadystatechange = null, "abort" === a ? h.abort() : "error" === a ? "number" != typeof h.status ? f(0, "error") : f(h.status, h.statusText) : f(Rb[h.status] || h.status, h.statusText, "text" !== (h.responseType || "text") || "string" != typeof h.responseText ? {
                              binary: h.response
                          } : {
                              text: h.responseText
                          }, h.getAllResponseHeaders()))
                      }
                  }, h.onload = c(), d = h.onerror = c("error"), void 0 !== h.onabort ? h.onabort = d : h.onreadystatechange = function() {
                      4 === h.readyState && a.setTimeout(function() {
                          c && d()
                      })
                  }, c = c("abort");
                  try {
                      h.send(b.hasContent && b.data || null)
                  } catch (i) {
                      if (c) throw i
                  }
              },
              abort: function() {
                  c && c()
              }
          }
      }), r.ajaxPrefilter(function(a) {
          a.crossDomain && (a.contents.script = !1)
      }), r.ajaxSetup({
          accepts: {
              script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
          },
          contents: {
              script: /\b(?:java|ecma)script\b/
          },
          converters: {
              "text script": function(a) {
                  return r.globalEval(a), a
              }
          }
      }), r.ajaxPrefilter("script", function(a) {
          void 0 === a.cache && (a.cache = !1), a.crossDomain && (a.type = "GET")
      }), r.ajaxTransport("script", function(a) {
          if (a.crossDomain) {
              var b, c;
              return {
                  send: function(e, f) {
                      b = r("<script>").prop({
                          charset: a.scriptCharset,
                          src: a.url
                      }).on("load error", c = function(a) {
                          b.remove(), c = null, a && f("error" === a.type ? 404 : 200, a.type)
                      }), d.head.appendChild(b[0])
                  },
                  abort: function() {
                      c && c()
                  }
              }
          }
      });
      var Tb = [],
          Ub = /(=)\?(?=&|$)|\?\?/;
      r.ajaxSetup({
          jsonp: "callback",
          jsonpCallback: function() {
              var a = Tb.pop() || r.expando + "_" + ub++;
              return this[a] = !0, a
          }
      }), r.ajaxPrefilter("json jsonp", function(b, c, d) {
          var e, f, g, h = b.jsonp !== !1 && (Ub.test(b.url) ? "url" : "string" == typeof b.data && 0 === (b.contentType || "").indexOf("application/x-www-form-urlencoded") && Ub.test(b.data) && "data");
          if (h || "jsonp" === b.dataTypes[0]) return e = b.jsonpCallback = r.isFunction(b.jsonpCallback) ? b.jsonpCallback() : b.jsonpCallback, h ? b[h] = b[h].replace(Ub, "$1" + e) : b.jsonp !== !1 && (b.url += (vb.test(b.url) ? "&" : "?") + b.jsonp + "=" + e), b.converters["script json"] = function() {
              return g || r.error(e + " was not called"), g[0]
          }, b.dataTypes[0] = "json", f = a[e], a[e] = function() {
              g = arguments
          }, d.always(function() {
              void 0 === f ? r(a).removeProp(e) : a[e] = f, b[e] && (b.jsonpCallback = c.jsonpCallback, Tb.push(e)), g && r.isFunction(f) && f(g[0]), g = f = void 0
          }), "script"
      }), o.createHTMLDocument = function() {
          var a = d.implementation.createHTMLDocument("").body;
          return a.innerHTML = "<form></form><form></form>", 2 === a.childNodes.length
      }(), r.parseHTML = function(a, b, c) {
          if ("string" != typeof a) return [];
          "boolean" == typeof b && (c = b, b = !1);
          var e, f, g;
          return b || (o.createHTMLDocument ? (b = d.implementation.createHTMLDocument(""), e = b.createElement("base"), e.href = d.location.href, b.head.appendChild(e)) : b = d), f = C.exec(a), g = !c && [], f ? [b.createElement(f[1])] : (f = qa([a], b, g), g && g.length && r(g).remove(), r.merge([], f.childNodes))
      }, r.fn.load = function(a, b, c) {
          var d, e, f, g = this,
              h = a.indexOf(" ");
          return h > -1 && (d = pb(a.slice(h)), a = a.slice(0, h)), r.isFunction(b) ? (c = b, b = void 0) : b && "object" == typeof b && (e = "POST"), g.length > 0 && r.ajax({
              url: a,
              type: e || "GET",
              dataType: "html",
              data: b
          }).done(function(a) {
              f = arguments, g.html(d ? r("<div>").append(r.parseHTML(a)).find(d) : a)
          }).always(c && function(a, b) {
              g.each(function() {
                  c.apply(this, f || [a.responseText, b, a])
              })
          }), this
      }, r.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(a, b) {
          r.fn[b] = function(a) {
              return this.on(b, a)
          }
      }), r.expr.pseudos.animated = function(a) {
          return r.grep(r.timers, function(b) {
              return a === b.elem
          }).length
      }, r.offset = {
          setOffset: function(a, b, c) {
              var d, e, f, g, h, i, j, k = r.css(a, "position"),
                  l = r(a),
                  m = {};
              "static" === k && (a.style.position = "relative"), h = l.offset(), f = r.css(a, "top"), i = r.css(a, "left"), j = ("absolute" === k || "fixed" === k) && (f + i).indexOf("auto") > -1, j ? (d = l.position(), g = d.top, e = d.left) : (g = parseFloat(f) || 0, e = parseFloat(i) || 0), r.isFunction(b) && (b = b.call(a, c, r.extend({}, h))), null != b.top && (m.top = b.top - h.top + g), null != b.left && (m.left = b.left - h.left + e), "using" in b ? b.using.call(a, m) : l.css(m)
          }
      }, r.fn.extend({
          offset: function(a) {
              if (arguments.length) return void 0 === a ? this : this.each(function(b) {
                  r.offset.setOffset(this, a, b)
              });
              var b, c, d, e, f = this[0];
              if (f) return f.getClientRects().length ? (d = f.getBoundingClientRect(), b = f.ownerDocument, c = b.documentElement, e = b.defaultView, {
                  top: d.top + e.pageYOffset - c.clientTop,
                  left: d.left + e.pageXOffset - c.clientLeft
              }) : {
                  top: 0,
                  left: 0
              }
          },
          position: function() {
              if (this[0]) {
                  var a, b, c = this[0],
                      d = {
                          top: 0,
                          left: 0
                      };
                  return "fixed" === r.css(c, "position") ? b = c.getBoundingClientRect() : (a = this.offsetParent(), b = this.offset(), B(a[0], "html") || (d = a.offset()), d = {
                      top: d.top + r.css(a[0], "borderTopWidth", !0),
                      left: d.left + r.css(a[0], "borderLeftWidth", !0)
                  }), {
                      top: b.top - d.top - r.css(c, "marginTop", !0),
                      left: b.left - d.left - r.css(c, "marginLeft", !0)
                  }
              }
          },
          offsetParent: function() {
              return this.map(function() {
                  var a = this.offsetParent;
                  while (a && "static" === r.css(a, "position")) a = a.offsetParent;
                  return a || ra
              })
          }
      }), r.each({
          scrollLeft: "pageXOffset",
          scrollTop: "pageYOffset"
      }, function(a, b) {
          var c = "pageYOffset" === b;
          r.fn[a] = function(d) {
              return T(this, function(a, d, e) {
                  var f;
                  return r.isWindow(a) ? f = a : 9 === a.nodeType && (f = a.defaultView), void 0 === e ? f ? f[b] : a[d] : void(f ? f.scrollTo(c ? f.pageXOffset : e, c ? e : f.pageYOffset) : a[d] = e)
              }, a, d, arguments.length)
          }
      }), r.each(["top", "left"], function(a, b) {
          r.cssHooks[b] = Pa(o.pixelPosition, function(a, c) {
              if (c) return c = Oa(a, b), Ma.test(c) ? r(a).position()[b] + "px" : c
          })
      }), r.each({
          Height: "height",
          Width: "width"
      }, function(a, b) {
          r.each({
              padding: "inner" + a,
              content: b,
              "": "outer" + a
          }, function(c, d) {
              r.fn[d] = function(e, f) {
                  var g = arguments.length && (c || "boolean" != typeof e),
                      h = c || (e === !0 || f === !0 ? "margin" : "border");
                  return T(this, function(b, c, e) {
                      var f;
                      return r.isWindow(b) ? 0 === d.indexOf("outer") ? b["inner" + a] : b.document.documentElement["client" + a] : 9 === b.nodeType ? (f = b.documentElement, Math.max(b.body["scroll" + a], f["scroll" + a], b.body["offset" + a], f["offset" + a], f["client" + a])) : void 0 === e ? r.css(b, c, h) : r.style(b, c, e, h)
                  }, b, g ? e : void 0, g)
              }
          })
      }), r.fn.extend({
          bind: function(a, b, c) {
              return this.on(a, null, b, c)
          },
          unbind: function(a, b) {
              return this.off(a, null, b)
          },
          delegate: function(a, b, c, d) {
              return this.on(b, a, c, d)
          },
          undelegate: function(a, b, c) {
              return 1 === arguments.length ? this.off(a, "**") : this.off(b, a || "**", c)
          }
      }), r.holdReady = function(a) {
          a ? r.readyWait++ : r.ready(!0)
      }, r.isArray = Array.isArray, r.parseJSON = JSON.parse, r.nodeName = B, "function" == typeof define && define.amd && define("jquery", [], function() {
          return r
      });
      var Vb = a.jQuery,
          Wb = a.$;
      return r.noConflict = function(b) {
          return a.$ === r && (a.$ = Wb), b && a.jQuery === r && (a.jQuery = Vb), r
      }, b || (a.jQuery = a.$ = r), r
  });
  /*
   Copyright (C) Federico Zivolo 2017
   Distributed under the MIT License (license terms are at http://opensource.org/licenses/MIT).
   */
  (function(e, t) {
      'object' == typeof exports && 'undefined' != typeof module ? module.exports = t() : 'function' == typeof define && define.amd ? define(t) : e.Popper = t()
  })(this, function() {
      'use strict';
  
      function e(e) {
          return e && '[object Function]' === {}.toString.call(e)
      }
  
      function t(e, t) {
          if (1 !== e.nodeType) return [];
          var o = window.getComputedStyle(e, null);
          return t ? o[t] : o
      }
  
      function o(e) {
          return 'HTML' === e.nodeName ? e : e.parentNode || e.host
      }
  
      function n(e) {
          if (!e || -1 !== ['HTML', 'BODY', '#document'].indexOf(e.nodeName)) return window.document.body;
          var i = t(e),
              r = i.overflow,
              p = i.overflowX,
              s = i.overflowY;
          return /(auto|scroll)/.test(r + s + p) ? e : n(o(e))
      }
  
      function r(e) {
          var o = e && e.offsetParent,
              i = o && o.nodeName;
          return i && 'BODY' !== i && 'HTML' !== i ? -1 !== ['TD', 'TABLE'].indexOf(o.nodeName) && 'static' === t(o, 'position') ? r(o) : o : window.document.documentElement
      }
  
      function p(e) {
          var t = e.nodeName;
          return 'BODY' !== t && ('HTML' === t || r(e.firstElementChild) === e)
      }
  
      function s(e) {
          return null === e.parentNode ? e : s(e.parentNode)
      }
  
      function d(e, t) {
          if (!e || !e.nodeType || !t || !t.nodeType) return window.document.documentElement;
          var o = e.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_FOLLOWING,
              i = o ? e : t,
              n = o ? t : e,
              a = document.createRange();
          a.setStart(i, 0), a.setEnd(n, 0);
          var f = a.commonAncestorContainer;
          if (e !== f && t !== f || i.contains(n)) return p(f) ? f : r(f);
          var l = s(e);
          return l.host ? d(l.host, t) : d(e, s(t).host)
      }
  
      function a(e) {
          var t = 1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : 'top',
              o = 'top' === t ? 'scrollTop' : 'scrollLeft',
              i = e.nodeName;
          if ('BODY' === i || 'HTML' === i) {
              var n = window.document.documentElement,
                  r = window.document.scrollingElement || n;
              return r[o]
          }
          return e[o]
      }
  
      function f(e, t) {
          var o = 2 < arguments.length && void 0 !== arguments[2] && arguments[2],
              i = a(t, 'top'),
              n = a(t, 'left'),
              r = o ? -1 : 1;
          return e.top += i * r, e.bottom += i * r, e.left += n * r, e.right += n * r, e
      }
  
      function l(e, t) {
          var o = 'x' === t ? 'Left' : 'Top',
              i = 'Left' == o ? 'Right' : 'Bottom';
          return +e['border' + o + 'Width'].split('px')[0] + +e['border' + i + 'Width'].split('px')[0]
      }
  
      function m(e, t, o, i) {
          return _(t['offset' + e], o['client' + e], o['offset' + e], ie() ? o['offset' + e] + i['margin' + ('Height' === e ? 'Top' : 'Left')] + i['margin' + ('Height' === e ? 'Bottom' : 'Right')] : 0)
      }
  
      function h() {
          var e = window.document.body,
              t = window.document.documentElement,
              o = ie() && window.getComputedStyle(t);
          return {
              height: m('Height', e, t, o),
              width: m('Width', e, t, o)
          }
      }
  
      function c(e) {
          return se({}, e, {
              right: e.left + e.width,
              bottom: e.top + e.height
          })
      }
  
      function g(e) {
          var o = {};
          if (ie()) try {
              o = e.getBoundingClientRect();
              var i = a(e, 'top'),
                  n = a(e, 'left');
              o.top += i, o.left += n, o.bottom += i, o.right += n
          } catch (e) {} else o = e.getBoundingClientRect();
          var r = {
                  left: o.left,
                  top: o.top,
                  width: o.right - o.left,
                  height: o.bottom - o.top
              },
              p = 'HTML' === e.nodeName ? h() : {},
              s = p.width || e.clientWidth || r.right - r.left,
              d = p.height || e.clientHeight || r.bottom - r.top,
              f = e.offsetWidth - s,
              m = e.offsetHeight - d;
          if (f || m) {
              var g = t(e);
              f -= l(g, 'x'), m -= l(g, 'y'), r.width -= f, r.height -= m
          }
          return c(r)
      }
  
      function u(e, o) {
          var i = ie(),
              r = 'HTML' === o.nodeName,
              p = g(e),
              s = g(o),
              d = n(e),
              a = t(o),
              l = +a.borderTopWidth.split('px')[0],
              m = +a.borderLeftWidth.split('px')[0],
              h = c({
                  top: p.top - s.top - l,
                  left: p.left - s.left - m,
                  width: p.width,
                  height: p.height
              });
          if (h.marginTop = 0, h.marginLeft = 0, !i && r) {
              var u = +a.marginTop.split('px')[0],
                  b = +a.marginLeft.split('px')[0];
              h.top -= l - u, h.bottom -= l - u, h.left -= m - b, h.right -= m - b, h.marginTop = u, h.marginLeft = b
          }
          return (i ? o.contains(d) : o === d && 'BODY' !== d.nodeName) && (h = f(h, o)), h
      }
  
      function b(e) {
          var t = window.document.documentElement,
              o = u(e, t),
              i = _(t.clientWidth, window.innerWidth || 0),
              n = _(t.clientHeight, window.innerHeight || 0),
              r = a(t),
              p = a(t, 'left'),
              s = {
                  top: r - o.top + o.marginTop,
                  left: p - o.left + o.marginLeft,
                  width: i,
                  height: n
              };
          return c(s)
      }
  
      function y(e) {
          var i = e.nodeName;
          return 'BODY' === i || 'HTML' === i ? !1 : 'fixed' === t(e, 'position') || y(o(e))
      }
  
      function w(e, t, i, r) {
          var p = {
                  top: 0,
                  left: 0
              },
              s = d(e, t);
          if ('viewport' === r) p = b(s);
          else {
              var a;
              'scrollParent' === r ? (a = n(o(e)), 'BODY' === a.nodeName && (a = window.document.documentElement)) : 'window' === r ? a = window.document.documentElement : a = r;
              var f = u(a, s);
              if ('HTML' === a.nodeName && !y(s)) {
                  var l = h(),
                      m = l.height,
                      c = l.width;
                  p.top += f.top - f.marginTop, p.bottom = m + f.top, p.left += f.left - f.marginLeft, p.right = c + f.left
              } else p = f
          }
          return p.left += i, p.top += i, p.right -= i, p.bottom -= i, p
      }
  
      function v(e) {
          var t = e.width,
              o = e.height;
          return t * o
      }
  
      function E(e, t, o, i, n) {
          var r = 5 < arguments.length && void 0 !== arguments[5] ? arguments[5] : 0;
          if (-1 === e.indexOf('auto')) return e;
          var p = w(o, i, r, n),
              s = {
                  top: {
                      width: p.width,
                      height: t.top - p.top
                  },
                  right: {
                      width: p.right - t.right,
                      height: p.height
                  },
                  bottom: {
                      width: p.width,
                      height: p.bottom - t.bottom
                  },
                  left: {
                      width: t.left - p.left,
                      height: p.height
                  }
              },
              d = Object.keys(s).map(function(e) {
                  return se({
                      key: e
                  }, s[e], {
                      area: v(s[e])
                  })
              }).sort(function(e, t) {
                  return t.area - e.area
              }),
              a = d.filter(function(e) {
                  var t = e.width,
                      i = e.height;
                  return t >= o.clientWidth && i >= o.clientHeight
              }),
              f = 0 < a.length ? a[0].key : d[0].key,
              l = e.split('-')[1];
          return f + (l ? '-' + l : '')
      }
  
      function x(e, t, o) {
          var i = d(t, o);
          return u(o, i)
      }
  
      function O(e) {
          var t = window.getComputedStyle(e),
              o = parseFloat(t.marginTop) + parseFloat(t.marginBottom),
              i = parseFloat(t.marginLeft) + parseFloat(t.marginRight),
              n = {
                  width: e.offsetWidth + i,
                  height: e.offsetHeight + o
              };
          return n
      }
  
      function L(e) {
          var t = {
              left: 'right',
              right: 'left',
              bottom: 'top',
              top: 'bottom'
          };
          return e.replace(/left|right|bottom|top/g, function(e) {
              return t[e]
          })
      }
  
      function S(e, t, o) {
          o = o.split('-')[0];
          var i = O(e),
              n = {
                  width: i.width,
                  height: i.height
              },
              r = -1 !== ['right', 'left'].indexOf(o),
              p = r ? 'top' : 'left',
              s = r ? 'left' : 'top',
              d = r ? 'height' : 'width',
              a = r ? 'width' : 'height';
          return n[p] = t[p] + t[d] / 2 - i[d] / 2, n[s] = o === s ? t[s] - i[a] : t[L(s)], n
      }
  
      function T(e, t) {
          return Array.prototype.find ? e.find(t) : e.filter(t)[0]
      }
  
      function C(e, t, o) {
          if (Array.prototype.findIndex) return e.findIndex(function(e) {
              return e[t] === o
          });
          var i = T(e, function(e) {
              return e[t] === o
          });
          return e.indexOf(i)
      }
  
      function N(t, o, i) {
          var n = void 0 === i ? t : t.slice(0, C(t, 'name', i));
          return n.forEach(function(t) {
              t.function && console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
              var i = t.function || t.fn;
              t.enabled && e(i) && (o.offsets.popper = c(o.offsets.popper), o.offsets.reference = c(o.offsets.reference), o = i(o, t))
          }), o
      }
  
      function k() {
          if (!this.state.isDestroyed) {
              var e = {
                  instance: this,
                  styles: {},
                  attributes: {},
                  flipped: !1,
                  offsets: {}
              };
              e.offsets.reference = x(this.state, this.popper, this.reference), e.placement = E(this.options.placement, e.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding), e.originalPlacement = e.placement, e.offsets.popper = S(this.popper, e.offsets.reference, e.placement), e.offsets.popper.position = 'absolute', e = N(this.modifiers, e), this.state.isCreated ? this.options.onUpdate(e) : (this.state.isCreated = !0, this.options.onCreate(e))
          }
      }
  
      function W(e, t) {
          return e.some(function(e) {
              var o = e.name,
                  i = e.enabled;
              return i && o === t
          })
      }
  
      function B(e) {
          for (var t = [!1, 'ms', 'Webkit', 'Moz', 'O'], o = e.charAt(0).toUpperCase() + e.slice(1), n = 0; n < t.length - 1; n++) {
              var i = t[n],
                  r = i ? '' + i + o : e;
              if ('undefined' != typeof window.document.body.style[r]) return r
          }
          return null
      }
  
      function D() {
          return this.state.isDestroyed = !0, W(this.modifiers, 'applyStyle') && (this.popper.removeAttribute('x-placement'), this.popper.style.left = '', this.popper.style.position = '', this.popper.style.top = '', this.popper.style[B('transform')] = ''), this.disableEventListeners(), this.options.removeOnDestroy && this.popper.parentNode.removeChild(this.popper), this
      }
  
      function H(e, t, o, i) {
          var r = 'BODY' === e.nodeName,
              p = r ? window : e;
          p.addEventListener(t, o, {
              passive: !0
          }), r || H(n(p.parentNode), t, o, i), i.push(p)
      }
  
      function P(e, t, o, i) {
          o.updateBound = i, window.addEventListener('resize', o.updateBound, {
              passive: !0
          });
          var r = n(e);
          return H(r, 'scroll', o.updateBound, o.scrollParents), o.scrollElement = r, o.eventsEnabled = !0, o
      }
  
      function A() {
          this.state.eventsEnabled || (this.state = P(this.reference, this.options, this.state, this.scheduleUpdate))
      }
  
      function M(e, t) {
          return window.removeEventListener('resize', t.updateBound), t.scrollParents.forEach(function(e) {
              e.removeEventListener('scroll', t.updateBound)
          }), t.updateBound = null, t.scrollParents = [], t.scrollElement = null, t.eventsEnabled = !1, t
      }
  
      function I() {
          this.state.eventsEnabled && (window.cancelAnimationFrame(this.scheduleUpdate), this.state = M(this.reference, this.state))
      }
  
      function R(e) {
          return '' !== e && !isNaN(parseFloat(e)) && isFinite(e)
      }
  
      function U(e, t) {
          Object.keys(t).forEach(function(o) {
              var i = ''; - 1 !== ['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(o) && R(t[o]) && (i = 'px'), e.style[o] = t[o] + i
          })
      }
  
      function Y(e, t) {
          Object.keys(t).forEach(function(o) {
              var i = t[o];
              !1 === i ? e.removeAttribute(o) : e.setAttribute(o, t[o])
          })
      }
  
      function F(e, t, o) {
          var i = T(e, function(e) {
                  var o = e.name;
                  return o === t
              }),
              n = !!i && e.some(function(e) {
                  return e.name === o && e.enabled && e.order < i.order
              });
          if (!n) {
              var r = '`' + t + '`';
              console.warn('`' + o + '`' + ' modifier is required by ' + r + ' modifier in order to work, be sure to include it before ' + r + '!')
          }
          return n
      }
  
      function j(e) {
          return 'end' === e ? 'start' : 'start' === e ? 'end' : e
      }
  
      function K(e) {
          var t = 1 < arguments.length && void 0 !== arguments[1] && arguments[1],
              o = ae.indexOf(e),
              i = ae.slice(o + 1).concat(ae.slice(0, o));
          return t ? i.reverse() : i
      }
  
      function q(e, t, o, i) {
          var n = e.match(/((?:\-|\+)?\d*\.?\d*)(.*)/),
              r = +n[1],
              p = n[2];
          if (!r) return e;
          if (0 === p.indexOf('%')) {
              var s;
              switch (p) {
                  case '%p':
                      s = o;
                      break;
                  case '%':
                  case '%r':
                  default:
                      s = i;
              }
              var d = c(s);
              return d[t] / 100 * r
          }
          if ('vh' === p || 'vw' === p) {
              var a;
              return a = 'vh' === p ? _(document.documentElement.clientHeight, window.innerHeight || 0) : _(document.documentElement.clientWidth, window.innerWidth || 0), a / 100 * r
          }
          return r
      }
  
      function G(e, t, o, i) {
          var n = [0, 0],
              r = -1 !== ['right', 'left'].indexOf(i),
              p = e.split(/(\+|\-)/).map(function(e) {
                  return e.trim()
              }),
              s = p.indexOf(T(p, function(e) {
                  return -1 !== e.search(/,|\s/)
              }));
          p[s] && -1 === p[s].indexOf(',') && console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
          var d = /\s*,\s*|\s+/,
              a = -1 === s ? [p] : [p.slice(0, s).concat([p[s].split(d)[0]]), [p[s].split(d)[1]].concat(p.slice(s + 1))];
          return a = a.map(function(e, i) {
              var n = (1 === i ? !r : r) ? 'height' : 'width',
                  p = !1;
              return e.reduce(function(e, t) {
                  return '' === e[e.length - 1] && -1 !== ['+', '-'].indexOf(t) ? (e[e.length - 1] = t, p = !0, e) : p ? (e[e.length - 1] += t, p = !1, e) : e.concat(t)
              }, []).map(function(e) {
                  return q(e, n, t, o)
              })
          }), a.forEach(function(e, t) {
              e.forEach(function(o, i) {
                  R(o) && (n[t] += o * ('-' === e[i - 1] ? -1 : 1))
              })
          }), n
      }
      for (var z = Math.min, V = Math.floor, _ = Math.max, X = ['native code', '[object MutationObserverConstructor]'], Q = function(e) {
              return X.some(function(t) {
                  return -1 < (e || '').toString().indexOf(t)
              })
          }, J = 'undefined' != typeof window, Z = ['Edge', 'Trident', 'Firefox'], $ = 0, ee = 0; ee < Z.length; ee += 1)
          if (J && 0 <= navigator.userAgent.indexOf(Z[ee])) {
              $ = 1;
              break
          }
      var i, te = J && Q(window.MutationObserver),
          oe = te ? function(e) {
              var t = !1,
                  o = 0,
                  i = document.createElement('span'),
                  n = new MutationObserver(function() {
                      e(), t = !1
                  });
              return n.observe(i, {
                      attributes: !0
                  }),
                  function() {
                      t || (t = !0, i.setAttribute('x-index', o), ++o)
                  }
          } : function(e) {
              var t = !1;
              return function() {
                  t || (t = !0, setTimeout(function() {
                      t = !1, e()
                  }, $))
              }
          },
          ie = function() {
              return void 0 == i && (i = -1 !== navigator.appVersion.indexOf('MSIE 10')), i
          },
          ne = function(e, t) {
              if (!(e instanceof t)) throw new TypeError('Cannot call a class as a function')
          },
          re = function() {
              function e(e, t) {
                  for (var o, n = 0; n < t.length; n++) o = t[n], o.enumerable = o.enumerable || !1, o.configurable = !0, 'value' in o && (o.writable = !0), Object.defineProperty(e, o.key, o)
              }
              return function(t, o, i) {
                  return o && e(t.prototype, o), i && e(t, i), t
              }
          }(),
          pe = function(e, t, o) {
              return t in e ? Object.defineProperty(e, t, {
                  value: o,
                  enumerable: !0,
                  configurable: !0,
                  writable: !0
              }) : e[t] = o, e
          },
          se = Object.assign || function(e) {
              for (var t, o = 1; o < arguments.length; o++)
                  for (var i in t = arguments[o], t) Object.prototype.hasOwnProperty.call(t, i) && (e[i] = t[i]);
              return e
          },
          de = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'],
          ae = de.slice(3),
          fe = {
              FLIP: 'flip',
              CLOCKWISE: 'clockwise',
              COUNTERCLOCKWISE: 'counterclockwise'
          },
          le = function() {
              function t(o, i) {
                  var n = this,
                      r = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : {};
                  ne(this, t), this.scheduleUpdate = function() {
                      return requestAnimationFrame(n.update)
                  }, this.update = oe(this.update.bind(this)), this.options = se({}, t.Defaults, r), this.state = {
                      isDestroyed: !1,
                      isCreated: !1,
                      scrollParents: []
                  }, this.reference = o.jquery ? o[0] : o, this.popper = i.jquery ? i[0] : i, this.options.modifiers = {}, Object.keys(se({}, t.Defaults.modifiers, r.modifiers)).forEach(function(e) {
                      n.options.modifiers[e] = se({}, t.Defaults.modifiers[e] || {}, r.modifiers ? r.modifiers[e] : {})
                  }), this.modifiers = Object.keys(this.options.modifiers).map(function(e) {
                      return se({
                          name: e
                      }, n.options.modifiers[e])
                  }).sort(function(e, t) {
                      return e.order - t.order
                  }), this.modifiers.forEach(function(t) {
                      t.enabled && e(t.onLoad) && t.onLoad(n.reference, n.popper, n.options, t, n.state)
                  }), this.update();
                  var p = this.options.eventsEnabled;
                  p && this.enableEventListeners(), this.state.eventsEnabled = p
              }
              return re(t, [{
                  key: 'update',
                  value: function() {
                      return k.call(this)
                  }
              }, {
                  key: 'destroy',
                  value: function() {
                      return D.call(this)
                  }
              }, {
                  key: 'enableEventListeners',
                  value: function() {
                      return A.call(this)
                  }
              }, {
                  key: 'disableEventListeners',
                  value: function() {
                      return I.call(this)
                  }
              }]), t
          }();
      return le.Utils = ('undefined' == typeof window ? global : window).PopperUtils, le.placements = de, le.Defaults = {
          placement: 'bottom',
          eventsEnabled: !0,
          removeOnDestroy: !1,
          onCreate: function() {},
          onUpdate: function() {},
          modifiers: {
              shift: {
                  order: 100,
                  enabled: !0,
                  fn: function(e) {
                      var t = e.placement,
                          o = t.split('-')[0],
                          i = t.split('-')[1];
                      if (i) {
                          var n = e.offsets,
                              r = n.reference,
                              p = n.popper,
                              s = -1 !== ['bottom', 'top'].indexOf(o),
                              d = s ? 'left' : 'top',
                              a = s ? 'width' : 'height',
                              f = {
                                  start: pe({}, d, r[d]),
                                  end: pe({}, d, r[d] + r[a] - p[a])
                              };
                          e.offsets.popper = se({}, p, f[i])
                      }
                      return e
                  }
              },
              offset: {
                  order: 200,
                  enabled: !0,
                  fn: function(e, t) {
                      var o, i = t.offset,
                          n = e.placement,
                          r = e.offsets,
                          p = r.popper,
                          s = r.reference,
                          d = n.split('-')[0];
                      return o = R(+i) ? [+i, 0] : G(i, p, s, d), 'left' === d ? (p.top += o[0], p.left -= o[1]) : 'right' === d ? (p.top += o[0], p.left += o[1]) : 'top' === d ? (p.left += o[0], p.top -= o[1]) : 'bottom' === d && (p.left += o[0], p.top += o[1]), e.popper = p, e
                  },
                  offset: 0
              },
              preventOverflow: {
                  order: 300,
                  enabled: !0,
                  fn: function(e, t) {
                      var o = t.boundariesElement || r(e.instance.popper);
                      e.instance.reference === o && (o = r(o));
                      var i = w(e.instance.popper, e.instance.reference, t.padding, o);
                      t.boundaries = i;
                      var n = t.priority,
                          p = e.offsets.popper,
                          s = {
                              primary: function(e) {
                                  var o = p[e];
                                  return p[e] < i[e] && !t.escapeWithReference && (o = _(p[e], i[e])), pe({}, e, o)
                              },
                              secondary: function(e) {
                                  var o = 'right' === e ? 'left' : 'top',
                                      n = p[o];
                                  return p[e] > i[e] && !t.escapeWithReference && (n = z(p[o], i[e] - ('right' === e ? p.width : p.height))), pe({}, o, n)
                              }
                          };
                      return n.forEach(function(e) {
                          var t = -1 === ['left', 'top'].indexOf(e) ? 'secondary' : 'primary';
                          p = se({}, p, s[t](e))
                      }), e.offsets.popper = p, e
                  },
                  priority: ['left', 'right', 'top', 'bottom'],
                  padding: 5,
                  boundariesElement: 'scrollParent'
              },
              keepTogether: {
                  order: 400,
                  enabled: !0,
                  fn: function(e) {
                      var t = e.offsets,
                          o = t.popper,
                          i = t.reference,
                          n = e.placement.split('-')[0],
                          r = V,
                          p = -1 !== ['top', 'bottom'].indexOf(n),
                          s = p ? 'right' : 'bottom',
                          d = p ? 'left' : 'top',
                          a = p ? 'width' : 'height';
                      return o[s] < r(i[d]) && (e.offsets.popper[d] = r(i[d]) - o[a]), o[d] > r(i[s]) && (e.offsets.popper[d] = r(i[s])), e
                  }
              },
              arrow: {
                  order: 500,
                  enabled: !0,
                  fn: function(e, t) {
                      if (!F(e.instance.modifiers, 'arrow', 'keepTogether')) return e;
                      var o = t.element;
                      if ('string' == typeof o) {
                          if (o = e.instance.popper.querySelector(o), !o) return e;
                      } else if (!e.instance.popper.contains(o)) return console.warn('WARNING: `arrow.element` must be child of its popper element!'), e;
                      var i = e.placement.split('-')[0],
                          n = e.offsets,
                          r = n.popper,
                          p = n.reference,
                          s = -1 !== ['left', 'right'].indexOf(i),
                          d = s ? 'height' : 'width',
                          a = s ? 'top' : 'left',
                          f = s ? 'left' : 'top',
                          l = s ? 'bottom' : 'right',
                          m = O(o)[d];
                      p[l] - m < r[a] && (e.offsets.popper[a] -= r[a] - (p[l] - m)), p[a] + m > r[l] && (e.offsets.popper[a] += p[a] + m - r[l]);
                      var h = p[a] + p[d] / 2 - m / 2,
                          g = h - c(e.offsets.popper)[a];
                      return g = _(z(r[d] - m, g), 0), e.arrowElement = o, e.offsets.arrow = {}, e.offsets.arrow[a] = Math.round(g), e.offsets.arrow[f] = '', e
                  },
                  element: '[x-arrow]'
              },
              flip: {
                  order: 600,
                  enabled: !0,
                  fn: function(e, t) {
                      if (W(e.instance.modifiers, 'inner')) return e;
                      if (e.flipped && e.placement === e.originalPlacement) return e;
                      var o = w(e.instance.popper, e.instance.reference, t.padding, t.boundariesElement),
                          i = e.placement.split('-')[0],
                          n = L(i),
                          r = e.placement.split('-')[1] || '',
                          p = [];
                      switch (t.behavior) {
                          case fe.FLIP:
                              p = [i, n];
                              break;
                          case fe.CLOCKWISE:
                              p = K(i);
                              break;
                          case fe.COUNTERCLOCKWISE:
                              p = K(i, !0);
                              break;
                          default:
                              p = t.behavior;
                      }
                      return p.forEach(function(s, d) {
                          if (i !== s || p.length === d + 1) return e;
                          i = e.placement.split('-')[0], n = L(i);
                          var a = e.offsets.popper,
                              f = e.offsets.reference,
                              l = V,
                              m = 'left' === i && l(a.right) > l(f.left) || 'right' === i && l(a.left) < l(f.right) || 'top' === i && l(a.bottom) > l(f.top) || 'bottom' === i && l(a.top) < l(f.bottom),
                              h = l(a.left) < l(o.left),
                              c = l(a.right) > l(o.right),
                              g = l(a.top) < l(o.top),
                              u = l(a.bottom) > l(o.bottom),
                              b = 'left' === i && h || 'right' === i && c || 'top' === i && g || 'bottom' === i && u,
                              y = -1 !== ['top', 'bottom'].indexOf(i),
                              w = !!t.flipVariations && (y && 'start' === r && h || y && 'end' === r && c || !y && 'start' === r && g || !y && 'end' === r && u);
                          (m || b || w) && (e.flipped = !0, (m || b) && (i = p[d + 1]), w && (r = j(r)), e.placement = i + (r ? '-' + r : ''), e.offsets.popper = se({}, e.offsets.popper, S(e.instance.popper, e.offsets.reference, e.placement)), e = N(e.instance.modifiers, e, 'flip'))
                      }), e
                  },
                  behavior: 'flip',
                  padding: 5,
                  boundariesElement: 'viewport'
              },
              inner: {
                  order: 700,
                  enabled: !1,
                  fn: function(e) {
                      var t = e.placement,
                          o = t.split('-')[0],
                          i = e.offsets,
                          n = i.popper,
                          r = i.reference,
                          p = -1 !== ['left', 'right'].indexOf(o),
                          s = -1 === ['top', 'left'].indexOf(o);
                      return n[p ? 'left' : 'top'] = r[t] - (s ? n[p ? 'width' : 'height'] : 0), e.placement = L(t), e.offsets.popper = c(n), e
                  }
              },
              hide: {
                  order: 800,
                  enabled: !0,
                  fn: function(e) {
                      if (!F(e.instance.modifiers, 'hide', 'preventOverflow')) return e;
                      var t = e.offsets.reference,
                          o = T(e.instance.modifiers, function(e) {
                              return 'preventOverflow' === e.name
                          }).boundaries;
                      if (t.bottom < o.top || t.left > o.right || t.top > o.bottom || t.right < o.left) {
                          if (!0 === e.hide) return e;
                          e.hide = !0, e.attributes['x-out-of-boundaries'] = ''
                      } else {
                          if (!1 === e.hide) return e;
                          e.hide = !1, e.attributes['x-out-of-boundaries'] = !1
                      }
                      return e
                  }
              },
              computeStyle: {
                  order: 850,
                  enabled: !0,
                  fn: function(e, t) {
                      var o = t.x,
                          i = t.y,
                          n = e.offsets.popper,
                          p = T(e.instance.modifiers, function(e) {
                              return 'applyStyle' === e.name
                          }).gpuAcceleration;
                      void 0 !== p && console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
                      var s, d, a = void 0 === p ? t.gpuAcceleration : p,
                          f = r(e.instance.popper),
                          l = g(f),
                          m = {
                              position: n.position
                          },
                          h = {
                              left: V(n.left),
                              top: V(n.top),
                              bottom: V(n.bottom),
                              right: V(n.right)
                          },
                          c = 'bottom' === o ? 'top' : 'bottom',
                          u = 'right' === i ? 'left' : 'right',
                          b = B('transform');
                      if (d = 'bottom' == c ? -l.height + h.bottom : h.top, s = 'right' == u ? -l.width + h.right : h.left, a && b) m[b] = 'translate3d(' + s + 'px, ' + d + 'px, 0)', m[c] = 0, m[u] = 0, m.willChange = 'transform';
                      else {
                          var y = 'bottom' == c ? -1 : 1,
                              w = 'right' == u ? -1 : 1;
                          m[c] = d * y, m[u] = s * w, m.willChange = c + ', ' + u
                      }
                      var v = {
                          "x-placement": e.placement
                      };
                      return e.attributes = se({}, v, e.attributes), e.styles = se({}, m, e.styles), e
                  },
                  gpuAcceleration: !0,
                  x: 'bottom',
                  y: 'right'
              },
              applyStyle: {
                  order: 900,
                  enabled: !0,
                  fn: function(e) {
                      return U(e.instance.popper, e.styles), Y(e.instance.popper, e.attributes), e.offsets.arrow && U(e.arrowElement, e.offsets.arrow), e
                  },
                  onLoad: function(e, t, o, i, n) {
                      var r = x(n, t, e),
                          p = E(o.placement, r, t, e, o.modifiers.flip.boundariesElement, o.modifiers.flip.padding);
                      return t.setAttribute('x-placement', p), U(t, {
                          position: 'absolute'
                      }), o
                  },
                  gpuAcceleration: void 0
              }
          }
      }, le
  });
  /*! version : 4.17.47
   =========================================================
   bootstrap-datetimejs
   https://github.com/Eonasdan/bootstrap-datetimepicker
   Copyright (c) 2015 Jonathan Peterson
   =========================================================
   */
  /*
   The MIT License (MIT)
  
   Copyright (c) 2015 Jonathan Peterson
  
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
   in the Software without restriction, including without limitation the rights
   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
  
   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.
  
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
   */
  /*global define:false */
  /*global exports:false */
  /*global require:false */
  /*global jQuery:false */
  /*global moment:false */
  
  /*
  
  
       Creative Tim Modifications
  
       We added class btn-primary for custom styling button.
  
  
  */
  
  ! function(e) {
      "use strict";
      if ("function" == typeof define && define.amd) define(["jquery", "moment"], e);
      else if ("object" == typeof exports) module.exports = e(require("jquery"), require("moment"));
      else {
          if ("undefined" == typeof jQuery) throw "bootstrap-datetimepicker requires jQuery to be loaded first";
          if ("undefined" == typeof moment) throw "bootstrap-datetimepicker requires Moment.js to be loaded first";
          e(jQuery, moment)
      }
  }(function(e, t) {
      "use strict";
      if (!t) throw new Error("bootstrap-datetimepicker requires Moment.js to be loaded first");
      var n = function(n, a) {
          var r, i, o, s, d, l, p, c = {},
              u = !0,
              f = !1,
              h = !1,
              m = 0,
              y = [{
                  clsName: "days",
                  navFnc: "M",
                  navStep: 1
              }, {
                  clsName: "months",
                  navFnc: "y",
                  navStep: 1
              }, {
                  clsName: "years",
                  navFnc: "y",
                  navStep: 10
              }, {
                  clsName: "decades",
                  navFnc: "y",
                  navStep: 100
              }],
              b = ["days", "months", "years", "decades"],
              g = ["top", "bottom", "auto"],
              w = ["left", "right", "auto"],
              v = ["default", "top", "bottom"],
              k = {
                  up: 38,
                  38: "up",
                  down: 40,
                  40: "down",
                  left: 37,
                  37: "left",
                  right: 39,
                  39: "right",
                  tab: 9,
                  9: "tab",
                  escape: 27,
                  27: "escape",
                  enter: 13,
                  13: "enter",
                  pageUp: 33,
                  33: "pageUp",
                  pageDown: 34,
                  34: "pageDown",
                  shift: 16,
                  16: "shift",
                  control: 17,
                  17: "control",
                  space: 32,
                  32: "space",
                  t: 84,
                  84: "t",
                  delete: 46,
                  46: "delete"
              },
              D = {},
              C = function() {
                  return void 0 !== t.tz && void 0 !== a.timeZone && null !== a.timeZone && "" !== a.timeZone
              },
              x = function(e) {
                  var n;
                  return n = void 0 === e || null === e ? t() : t.isDate(e) || t.isMoment(e) ? t(e) : C() ? t.tz(e, l, a.useStrict, a.timeZone) : t(e, l, a.useStrict), C() && n.tz(a.timeZone), n
              },
              T = function(e) {
                  if ("string" != typeof e || e.length > 1) throw new TypeError("isEnabled expects a single character string parameter");
                  switch (e) {
                      case "y":
                          return -1 !== d.indexOf("Y");
                      case "M":
                          return -1 !== d.indexOf("M");
                      case "d":
                          return -1 !== d.toLowerCase().indexOf("d");
                      case "h":
                      case "H":
                          return -1 !== d.toLowerCase().indexOf("h");
                      case "m":
                          return -1 !== d.indexOf("m");
                      case "s":
                          return -1 !== d.indexOf("s");
                      default:
                          return !1
                  }
              },
              M = function() {
                  return T("h") || T("m") || T("s")
              },
              S = function() {
                  return T("y") || T("M") || T("d")
              },
              O = function() {
                  var t = e("<thead>").append(e("<tr>").append(e("<th>").addClass("prev").attr("data-action", "previous").append(e("<span>").addClass(a.icons.previous))).append(e("<th>").addClass("picker-switch").attr("data-action", "pickerSwitch").attr("colspan", a.calendarWeeks ? "6" : "5")).append(e("<th>").addClass("next").attr("data-action", "next").append(e("<span>").addClass(a.icons.next)))),
                      n = e("<tbody>").append(e("<tr>").append(e("<td>").attr("colspan", a.calendarWeeks ? "8" : "7")));
                  return [e("<div>").addClass("datepicker-days").append(e("<table>").addClass("table-condensed").append(t).append(e("<tbody>"))), e("<div>").addClass("datepicker-months").append(e("<table>").addClass("table-condensed").append(t.clone()).append(n.clone())), e("<div>").addClass("datepicker-years").append(e("<table>").addClass("table-condensed").append(t.clone()).append(n.clone())), e("<div>").addClass("datepicker-decades").append(e("<table>").addClass("table-condensed").append(t.clone()).append(n.clone()))]
              },
              P = function() {
                  var t = e("<tr>"),
                      n = e("<tr>"),
                      r = e("<tr>");
                  return T("h") && (t.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.incrementHour
                  }).addClass("btn").attr("data-action", "incrementHours").append(e("<span>").addClass(a.icons.up)))), n.append(e("<td>").append(e("<span>").addClass("timepicker-hour").attr({
                      "data-time-component": "hours",
                      title: a.tooltips.pickHour
                  }).attr("data-action", "showHours"))), r.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.decrementHour
                  }).addClass("btn").attr("data-action", "decrementHours").append(e("<span>").addClass(a.icons.down))))), T("m") && (T("h") && (t.append(e("<td>").addClass("separator")), n.append(e("<td>").addClass("separator").html(":")), r.append(e("<td>").addClass("separator"))), t.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.incrementMinute
                  }).addClass("btn").attr("data-action", "incrementMinutes").append(e("<span>").addClass(a.icons.up)))), n.append(e("<td>").append(e("<span>").addClass("timepicker-minute").attr({
                      "data-time-component": "minutes",
                      title: a.tooltips.pickMinute
                  }).attr("data-action", "showMinutes"))), r.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.decrementMinute
                  }).addClass("btn").attr("data-action", "decrementMinutes").append(e("<span>").addClass(a.icons.down))))), T("s") && (T("m") && (t.append(e("<td>").addClass("separator")), n.append(e("<td>").addClass("separator").html(":")), r.append(e("<td>").addClass("separator"))), t.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.incrementSecond
                  }).addClass("btn btn-link").attr("data-action", "incrementSeconds").append(e("<span>").addClass(a.icons.up)))), n.append(e("<td>").append(e("<span>").addClass("timepicker-second").attr({
                      "data-time-component": "seconds",
                      title: a.tooltips.pickSecond
                  }).attr("data-action", "showSeconds"))), r.append(e("<td>").append(e("<a>").attr({
                      href: "#",
                      tabindex: "-1",
                      title: a.tooltips.decrementSecond
                  }).addClass("btn btn-link").attr("data-action", "decrementSeconds").append(e("<span>").addClass(a.icons.down))))), s || (t.append(e("<td>").addClass("separator")), n.append(e("<td>").append(e("<button>").addClass("btn btn-primary").attr({
                      "data-action": "togglePeriod",
                      tabindex: "-1",
                      title: a.tooltips.togglePeriod
                  }))), r.append(e("<td>").addClass("separator"))), e("<div>").addClass("timepicker-picker").append(e("<table>").addClass("table-condensed").append([t, n, r]))
              },
              E = function() {
                  var t = e("<div>").addClass("timepicker-hours").append(e("<table>").addClass("table-condensed")),
                      n = e("<div>").addClass("timepicker-minutes").append(e("<table>").addClass("table-condensed")),
                      a = e("<div>").addClass("timepicker-seconds").append(e("<table>").addClass("table-condensed")),
                      r = [P()];
                  return T("h") && r.push(t), T("m") && r.push(n), T("s") && r.push(a), r
              },
              H = function() {
                  var t = [];
                  return a.showTodayButton && t.push(e("<td>").append(e("<a>").attr({
                      "data-action": "today",
                      title: a.tooltips.today
                  }).append(e("<span>").addClass(a.icons.today)))), !a.sideBySide && S() && M() && t.push(e("<td>").append(e("<a>").attr({
                      "data-action": "togglePicker",
                      title: a.tooltips.selectTime
                  }).append(e("<span>").addClass(a.icons.time)))), a.showClear && t.push(e("<td>").append(e("<a>").attr({
                      "data-action": "clear",
                      title: a.tooltips.clear
                  }).append(e("<span>").addClass(a.icons.clear)))), a.showClose && t.push(e("<td>").append(e("<a>").attr({
                      "data-action": "close",
                      title: a.tooltips.close
                  }).append(e("<span>").addClass(a.icons.close)))), e("<table>").addClass("table-condensed").append(e("<tbody>").append(e("<tr>").append(t)))
              },
              I = function() {
                  var t = e("<div>").addClass("bootstrap-datetimepicker-widget dropdown-menu"),
                      n = e("<div>").addClass("datepicker").append(O()),
                      r = e("<div>").addClass("timepicker").append(E()),
                      i = e("<ul>").addClass("list-unstyled"),
                      o = e("<li>").addClass("picker-switch" + (a.collapse ? " accordion-toggle" : "")).append(H());
                  return a.inline && t.removeClass("dropdown-menu"), s && t.addClass("usetwentyfour"), T("s") && !s && t.addClass("wider"), a.sideBySide && S() && M() ? (t.addClass("timepicker-sbs"), "top" === a.toolbarPlacement && t.append(o), t.append(e("<div>").addClass("row").append(n.addClass("col-md-6")).append(r.addClass("col-md-6"))), "bottom" === a.toolbarPlacement && t.append(o), t) : ("top" === a.toolbarPlacement && i.append(o), S() && i.append(e("<li>").addClass(a.collapse && M() ? "collapse show" : "").append(n)), "default" === a.toolbarPlacement && i.append(o), M() && i.append(e("<li>").addClass(a.collapse && S() ? "collapse" : "").append(r)), "bottom" === a.toolbarPlacement && i.append(o), t.append(i))
              },
              Y = function() {
                  var t, r = (f || n).position(),
                      i = (f || n).offset(),
                      o = a.widgetPositioning.vertical,
                      s = a.widgetPositioning.horizontal;
                  if (a.widgetParent) t = a.widgetParent.append(h);
                  else if (n.is("input")) t = n.after(h).parent();
                  else {
                      if (a.inline) return void(t = n.append(h));
                      t = n, n.children().first().after(h)
                  }
                  if ("auto" === o && (o = i.top + 1.5 * h.height() >= e(window).height() + e(window).scrollTop() && h.height() + n.outerHeight() < i.top ? "top" : "bottom"), "auto" === s && (s = t.width() < i.left + h.outerWidth() / 2 && i.left + h.outerWidth() > e(window).width() ? "right" : "left"), "top" === o ? h.addClass("top").removeClass("bottom") : h.addClass("bottom").removeClass("top"), "right" === s ? h.addClass("pull-right") : h.removeClass("pull-right"), "static" === t.css("position") && (t = t.parents().filter(function() {
                          return "static" !== e(this).css("position")
                      }).first()), 0 === t.length) throw new Error("datetimepicker component should be placed within a non-static positioned container");
                  h.css({
                      top: "top" === o ? "auto" : r.top + n.outerHeight(),
                      bottom: "top" === o ? t.outerHeight() - (t === n ? 0 : r.top) : "auto",
                      left: "left" === s ? t === n ? 0 : r.left : "auto",
                      right: "left" === s ? "auto" : t.outerWidth() - n.outerWidth() - (t === n ? 0 : r.left)
                  }), setTimeout(function() {
                      h.addClass("open")
                  }, 180)
              },
              q = function(e) {
                  "dp.change" === e.type && (e.date && e.date.isSame(e.oldDate) || !e.date && !e.oldDate) || n.trigger(e)
              },
              B = function(e) {
                  "y" === e && (e = "YYYY"), q({
                      type: "dp.update",
                      change: e,
                      viewDate: i.clone()
                  })
              },
              j = function(e) {
                  h && (e && (p = Math.max(m, Math.min(3, p + e))), h.find(".datepicker > div").hide().filter(".datepicker-" + y[p].clsName).show())
              },
              A = function() {
                  var t = e("<tr>"),
                      n = i.clone().startOf("w").startOf("d");
                  for (!0 === a.calendarWeeks && t.append(e("<th>").addClass("cw").text("#")); n.isBefore(i.clone().endOf("w"));) t.append(e("<th>").addClass("dow").text(n.format("dd"))), n.add(1, "d");
                  h.find(".datepicker-days thead").append(t)
              },
              F = function(e) {
                  return !0 === a.disabledDates[e.format("YYYY-MM-DD")]
              },
              L = function(e) {
                  return !0 === a.enabledDates[e.format("YYYY-MM-DD")]
              },
              W = function(e) {
                  return !0 === a.disabledHours[e.format("H")]
              },
              z = function(e) {
                  return !0 === a.enabledHours[e.format("H")]
              },
              N = function(t, n) {
                  if (!t.isValid()) return !1;
                  if (a.disabledDates && "d" === n && F(t)) return !1;
                  if (a.enabledDates && "d" === n && !L(t)) return !1;
                  if (a.minDate && t.isBefore(a.minDate, n)) return !1;
                  if (a.maxDate && t.isAfter(a.maxDate, n)) return !1;
                  if (a.daysOfWeekDisabled && "d" === n && -1 !== a.daysOfWeekDisabled.indexOf(t.day())) return !1;
                  if (a.disabledHours && ("h" === n || "m" === n || "s" === n) && W(t)) return !1;
                  if (a.enabledHours && ("h" === n || "m" === n || "s" === n) && !z(t)) return !1;
                  if (a.disabledTimeIntervals && ("h" === n || "m" === n || "s" === n)) {
                      var r = !1;
                      if (e.each(a.disabledTimeIntervals, function() {
                              if (t.isBetween(this[0], this[1])) return r = !0, !1
                          }), r) return !1
                  }
                  return !0
              },
              V = function() {
                  for (var t = [], n = i.clone().startOf("y").startOf("d"); n.isSame(i, "y");) t.push(e("<span>").attr("data-action", "selectMonth").addClass("month").text(n.format("MMM"))), n.add(1, "M");
                  h.find(".datepicker-months td").empty().append(t)
              },
              Z = function() {
                  var t = h.find(".datepicker-months"),
                      n = t.find("th"),
                      o = t.find("tbody").find("span");
                  n.eq(0).find("span").attr("title", a.tooltips.prevYear), n.eq(1).attr("title", a.tooltips.selectYear), n.eq(2).find("span").attr("title", a.tooltips.nextYear), t.find(".disabled").removeClass("disabled"), N(i.clone().subtract(1, "y"), "y") || n.eq(0).addClass("disabled"), n.eq(1).text(i.year()), N(i.clone().add(1, "y"), "y") || n.eq(2).addClass("disabled"), o.removeClass("active"), r.isSame(i, "y") && !u && o.eq(r.month()).addClass("active"), o.each(function(t) {
                      N(i.clone().month(t), "M") || e(this).addClass("disabled")
                  })
              },
              R = function() {
                  var e = h.find(".datepicker-years"),
                      t = e.find("th"),
                      n = i.clone().subtract(5, "y"),
                      o = i.clone().add(6, "y"),
                      s = "";
                  for (t.eq(0).find("span").attr("title", a.tooltips.prevDecade), t.eq(1).attr("title", a.tooltips.selectDecade), t.eq(2).find("span").attr("title", a.tooltips.nextDecade), e.find(".disabled").removeClass("disabled"), a.minDate && a.minDate.isAfter(n, "y") && t.eq(0).addClass("disabled"), t.eq(1).text(n.year() + "-" + o.year()), a.maxDate && a.maxDate.isBefore(o, "y") && t.eq(2).addClass("disabled"); !n.isAfter(o, "y");) s += '<span data-action="selectYear" class="year' + (n.isSame(r, "y") && !u ? " active" : "") + (N(n, "y") ? "" : " disabled") + '">' + n.year() + "</span>", n.add(1, "y");
                  e.find("td").html(s)
              },
              Q = function() {
                  var e, n = h.find(".datepicker-decades"),
                      o = n.find("th"),
                      s = t({
                          y: i.year() - i.year() % 100 - 1
                      }),
                      d = s.clone().add(100, "y"),
                      l = s.clone(),
                      p = !1,
                      c = !1,
                      u = "";
                  for (o.eq(0).find("span").attr("title", a.tooltips.prevCentury), o.eq(2).find("span").attr("title", a.tooltips.nextCentury), n.find(".disabled").removeClass("disabled"), (s.isSame(t({
                          y: 1900
                      })) || a.minDate && a.minDate.isAfter(s, "y")) && o.eq(0).addClass("disabled"), o.eq(1).text(s.year() + "-" + d.year()), (s.isSame(t({
                          y: 2e3
                      })) || a.maxDate && a.maxDate.isBefore(d, "y")) && o.eq(2).addClass("disabled"); !s.isAfter(d, "y");) e = s.year() + 12, p = a.minDate && a.minDate.isAfter(s, "y") && a.minDate.year() <= e, c = a.maxDate && a.maxDate.isAfter(s, "y") && a.maxDate.year() <= e, u += '<span data-action="selectDecade" class="decade' + (r.isAfter(s) && r.year() <= e ? " active" : "") + (N(s, "y") || p || c ? "" : " disabled") + '" data-selection="' + (s.year() + 6) + '">' + (s.year() + 1) + " - " + (s.year() + 12) + "</span>", s.add(12, "y");
                  u += "<span></span><span></span><span></span>", n.find("td").html(u), o.eq(1).text(l.year() + 1 + "-" + s.year())
              },
              U = function() {
                  var t, n, o, s = h.find(".datepicker-days"),
                      d = s.find("th"),
                      l = [],
                      p = [];
                  if (S()) {
                      for (d.eq(0).find("span").attr("title", a.tooltips.prevMonth), d.eq(1).attr("title", a.tooltips.selectMonth), d.eq(2).find("span").attr("title", a.tooltips.nextMonth), s.find(".disabled").removeClass("disabled"), d.eq(1).text(i.format(a.dayViewHeaderFormat)), N(i.clone().subtract(1, "M"), "M") || d.eq(0).addClass("disabled"), N(i.clone().add(1, "M"), "M") || d.eq(2).addClass("disabled"), t = i.clone().startOf("M").startOf("w").startOf("d"), o = 0; o < 42; o++) 0 === t.weekday() && (n = e("<tr>"), a.calendarWeeks && n.append('<td class="cw">' + t.week() + "</td>"), l.push(n)), p = ["day"], t.isBefore(i, "M") && p.push("old"), t.isAfter(i, "M") && p.push("new"), t.isSame(r, "d") && !u && p.push("active"), N(t, "d") || p.push("disabled"), t.isSame(x(), "d") && p.push("today"), 0 !== t.day() && 6 !== t.day() || p.push("weekend"), q({
                          type: "dp.classify",
                          date: t,
                          classNames: p
                      }), n.append('<td data-action="selectDay" data-day="' + t.format("L") + '" class="' + p.join(" ") + '"><div>' + t.date() + "</div></td>"), t.add(1, "d");
                      s.find("tbody").empty().append(l), Z(), R(), Q()
                  }
              },
              G = function() {
                  var t = h.find(".timepicker-hours table"),
                      n = i.clone().startOf("d"),
                      a = [],
                      r = e("<tr>");
                  for (i.hour() > 11 && !s && n.hour(12); n.isSame(i, "d") && (s || i.hour() < 12 && n.hour() < 12 || i.hour() > 11);) n.hour() % 4 == 0 && (r = e("<tr>"), a.push(r)), r.append('<td data-action="selectHour" class="hour' + (N(n, "h") ? "" : " disabled") + '"><div>' + n.format(s ? "HH" : "hh") + "</div></td>"), n.add(1, "h");
                  t.empty().append(a)
              },
              J = function() {
                  for (var t = h.find(".timepicker-minutes table"), n = i.clone().startOf("h"), r = [], o = e("<tr>"), s = 1 === a.stepping ? 5 : a.stepping; i.isSame(n, "h");) n.minute() % (4 * s) == 0 && (o = e("<tr>"), r.push(o)), o.append('<td data-action="selectMinute" class="minute' + (N(n, "m") ? "" : " disabled") + '"><div>' + n.format("mm") + "</div></td>"), n.add(s, "m");
                  t.empty().append(r)
              },
              K = function() {
                  for (var t = h.find(".timepicker-seconds table"), n = i.clone().startOf("m"), a = [], r = e("<tr>"); i.isSame(n, "m");) n.second() % 20 == 0 && (r = e("<tr>"), a.push(r)), r.append('<td data-action="selectSecond" class="second' + (N(n, "s") ? "" : " disabled") + '"><div>' + n.format("ss") + "</div></td>"), n.add(5, "s");
                  t.empty().append(a)
              },
              X = function() {
                  var e, t, n = h.find(".timepicker span[data-time-component]");
                  s || (e = h.find(".timepicker [data-action=togglePeriod]"), t = r.clone().add(r.hours() >= 12 ? -12 : 12, "h"), e.text(r.format("A")), N(t, "h") ? e.removeClass("disabled") : e.addClass("disabled")), n.filter("[data-time-component=hours]").text(r.format(s ? "HH" : "hh")), n.filter("[data-time-component=minutes]").text(r.format("mm")), n.filter("[data-time-component=seconds]").text(r.format("ss")), G(), J(), K()
              },
              $ = function() {
                  h && (U(), X())
              },
              _ = function(e) {
                  var t = u ? null : r;
                  if (!e) return u = !0, o.val(""), n.data("date", ""), q({
                      type: "dp.change",
                      date: !1,
                      oldDate: t
                  }), void $();
                  if (e = e.clone().locale(a.locale), C() && e.tz(a.timeZone), 1 !== a.stepping)
                      for (e.minutes(Math.round(e.minutes() / a.stepping) * a.stepping).seconds(0); a.minDate && e.isBefore(a.minDate);) e.add(a.stepping, "minutes");
                  N(e) ? (i = (r = e).clone(), o.val(r.format(d)), n.data("date", r.format(d)), u = !1, $(), q({
                      type: "dp.change",
                      date: r.clone(),
                      oldDate: t
                  })) : (a.keepInvalid ? q({
                      type: "dp.change",
                      date: e,
                      oldDate: t
                  }) : o.val(u ? "" : r.format(d)), q({
                      type: "dp.error",
                      date: e,
                      oldDate: t
                  }))
              },
              ee = function() {
                  var t = !1;
                  return h ? (h.find(".collapse").each(function() {
                      var n = e(this).data("collapse");
                      return !n || !n.transitioning || (t = !0, !1)
                  }), t ? c : (f && f.hasClass("btn") && f.toggleClass("active"), e(window).off("resize", Y), h.off("click", "[data-action]"), h.off("mousedown", !1), h.removeClass("open"), void setTimeout(function() {
                      return h.remove(), h.hide(), h = !1, q({
                          type: "dp.hide",
                          date: r.clone()
                      }), o.blur(), p = 0, i = r.clone(), c
                  }, 400))) : c
              },
              te = function() {
                  _(null)
              },
              ne = function(e) {
                  return void 0 === a.parseInputDate ? (!t.isMoment(e) || e instanceof Date) && (e = x(e)) : e = a.parseInputDate(e), e
              },
              ae = {
                  next: function() {
                      var e = y[p].navFnc;
                      i.add(y[p].navStep, e), U(), B(e)
                  },
                  previous: function() {
                      var e = y[p].navFnc;
                      i.subtract(y[p].navStep, e), U(), B(e)
                  },
                  pickerSwitch: function() {
                      j(1)
                  },
                  selectMonth: function(t) {
                      var n = e(t.target).closest("tbody").find("span").index(e(t.target));
                      i.month(n), p === m ? (_(r.clone().year(i.year()).month(i.month())), a.inline || ee()) : (j(-1), U()), B("M")
                  },
                  selectYear: function(t) {
                      var n = parseInt(e(t.target).text(), 10) || 0;
                      i.year(n), p === m ? (_(r.clone().year(i.year())), a.inline || ee()) : (j(-1), U()), B("YYYY")
                  },
                  selectDecade: function(t) {
                      var n = parseInt(e(t.target).data("selection"), 10) || 0;
                      i.year(n), p === m ? (_(r.clone().year(i.year())), a.inline || ee()) : (j(-1), U()), B("YYYY")
                  },
                  selectDay: function(t) {
                      var n = i.clone();
                      e(t.target).is(".old") && n.subtract(1, "M"), e(t.target).is(".new") && n.add(1, "M"), _(n.date(parseInt(e(t.target).text(), 10))), M() || a.keepOpen || a.inline || ee()
                  },
                  incrementHours: function() {
                      var e = r.clone().add(1, "h");
                      N(e, "h") && _(e)
                  },
                  incrementMinutes: function() {
                      var e = r.clone().add(a.stepping, "m");
                      N(e, "m") && _(e)
                  },
                  incrementSeconds: function() {
                      var e = r.clone().add(1, "s");
                      N(e, "s") && _(e)
                  },
                  decrementHours: function() {
                      var e = r.clone().subtract(1, "h");
                      N(e, "h") && _(e)
                  },
                  decrementMinutes: function() {
                      var e = r.clone().subtract(a.stepping, "m");
                      N(e, "m") && _(e)
                  },
                  decrementSeconds: function() {
                      var e = r.clone().subtract(1, "s");
                      N(e, "s") && _(e)
                  },
                  togglePeriod: function() {
                      _(r.clone().add(r.hours() >= 12 ? -12 : 12, "h"))
                  },
                  togglePicker: function(t) {
                      var n, r = e(t.target),
                          i = r.closest("ul"),
                          o = i.find(".show"),
                          s = i.find(".collapse:not(.show)");
                      if (o && o.length) {
                          if ((n = o.data("collapse")) && n.transitioning) return;
                          o.collapse ? (o.collapse("hide"), s.collapse("show")) : (o.removeClass("show"), s.addClass("show")), r.is("span") ? r.toggleClass(a.icons.time + " " + a.icons.date) : r.find("span").toggleClass(a.icons.time + " " + a.icons.date)
                      }
                  },
                  showPicker: function() {
                      h.find(".timepicker > div:not(.timepicker-picker)").hide(), h.find(".timepicker .timepicker-picker").show()
                  },
                  showHours: function() {
                      h.find(".timepicker .timepicker-picker").hide(), h.find(".timepicker .timepicker-hours").show()
                  },
                  showMinutes: function() {
                      h.find(".timepicker .timepicker-picker").hide(), h.find(".timepicker .timepicker-minutes").show()
                  },
                  showSeconds: function() {
                      h.find(".timepicker .timepicker-picker").hide(), h.find(".timepicker .timepicker-seconds").show()
                  },
                  selectHour: function(t) {
                      var n = parseInt(e(t.target).text(), 10);
                      s || (r.hours() >= 12 ? 12 !== n && (n += 12) : 12 === n && (n = 0)), _(r.clone().hours(n)), ae.showPicker.call(c)
                  },
                  selectMinute: function(t) {
                      _(r.clone().minutes(parseInt(e(t.target).text(), 10))), ae.showPicker.call(c)
                  },
                  selectSecond: function(t) {
                      _(r.clone().seconds(parseInt(e(t.target).text(), 10))), ae.showPicker.call(c)
                  },
                  clear: te,
                  today: function() {
                      var e = x();
                      N(e, "d") && _(e)
                  },
                  close: ee
              },
              re = function(t) {
                  return !e(t.currentTarget).is(".disabled") && (ae[e(t.currentTarget).data("action")].apply(c, arguments), !1)
              },
              ie = function() {
                  var t, n = {
                      year: function(e) {
                          return e.month(0).date(1).hours(0).seconds(0).minutes(0)
                      },
                      month: function(e) {
                          return e.date(1).hours(0).seconds(0).minutes(0)
                      },
                      day: function(e) {
                          return e.hours(0).seconds(0).minutes(0)
                      },
                      hour: function(e) {
                          return e.seconds(0).minutes(0)
                      },
                      minute: function(e) {
                          return e.seconds(0)
                      }
                  };
                  return o.prop("disabled") || !a.ignoreReadonly && o.prop("readonly") || h ? c : (void 0 !== o.val() && 0 !== o.val().trim().length ? _(ne(o.val().trim())) : u && a.useCurrent && (a.inline || o.is("input") && 0 === o.val().trim().length) && (t = x(), "string" == typeof a.useCurrent && (t = n[a.useCurrent](t)), _(t)), h = I(), A(), V(), h.find(".timepicker-hours").hide(), h.find(".timepicker-minutes").hide(), h.find(".timepicker-seconds").hide(), $(), j(), e(window).on("resize", Y), h.on("click", "[data-action]", re), h.on("mousedown", !1), f && f.hasClass("btn") && f.toggleClass("active"), Y(), h.show(), a.focusOnShow && !o.is(":focus") && o.focus(), q({
                      type: "dp.show"
                  }), c)
              },
              oe = function() {
                  return h ? ee() : ie()
              },
              se = function(e) {
                  var t, n, r, i, o = null,
                      s = [],
                      d = {},
                      l = e.which;
                  D[l] = "p";
                  for (t in D) D.hasOwnProperty(t) && "p" === D[t] && (s.push(t), parseInt(t, 10) !== l && (d[t] = !0));
                  for (t in a.keyBinds)
                      if (a.keyBinds.hasOwnProperty(t) && "function" == typeof a.keyBinds[t] && (r = t.split(" ")).length === s.length && k[l] === r[r.length - 1]) {
                          for (i = !0, n = r.length - 2; n >= 0; n--)
                              if (!(k[r[n]] in d)) {
                                  i = !1;
                                  break
                              }
                          if (i) {
                              o = a.keyBinds[t];
                              break
                          }
                      }
                  o && (o.call(c, h), e.stopPropagation(), e.preventDefault())
              },
              de = function(e) {
                  D[e.which] = "r", e.stopPropagation(), e.preventDefault()
              },
              le = function(t) {
                  var n = e(t.target).val().trim(),
                      a = n ? ne(n) : null;
                  return _(a), t.stopImmediatePropagation(), !1
              },
              pe = function() {
                  o.off({
                      change: le,
                      blur: blur,
                      keydown: se,
                      keyup: de,
                      focus: a.allowInputToggle ? ee : ""
                  }), n.is("input") ? o.off({
                      focus: ie
                  }) : f && (f.off("click", oe), f.off("mousedown", !1))
              },
              ce = function(t) {
                  var n = {};
                  return e.each(t, function() {
                      var e = ne(this);
                      e.isValid() && (n[e.format("YYYY-MM-DD")] = !0)
                  }), !!Object.keys(n).length && n
              },
              ue = function(t) {
                  var n = {};
                  return e.each(t, function() {
                      n[this] = !0
                  }), !!Object.keys(n).length && n
              },
              fe = function() {
                  var e = a.format || "L LT";
                  d = e.replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function(e) {
                      return (r.localeData().longDateFormat(e) || e).replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function(e) {
                          return r.localeData().longDateFormat(e) || e
                      })
                  }), (l = a.extraFormats ? a.extraFormats.slice() : []).indexOf(e) < 0 && l.indexOf(d) < 0 && l.push(d), s = d.toLowerCase().indexOf("a") < 1 && d.replace(/\[.*?\]/g, "").indexOf("h") < 1, T("y") && (m = 2), T("M") && (m = 1), T("d") && (m = 0), p = Math.max(m, p), u || _(r)
              };
          if (c.destroy = function() {
                  ee(), pe(), n.removeData("DateTimePicker"), n.removeData("date")
              }, c.toggle = oe, c.show = ie, c.hide = ee, c.disable = function() {
                  return ee(), f && f.hasClass("btn") && f.addClass("disabled"), o.prop("disabled", !0), c
              }, c.enable = function() {
                  return f && f.hasClass("btn") && f.removeClass("disabled"), o.prop("disabled", !1), c
              }, c.ignoreReadonly = function(e) {
                  if (0 === arguments.length) return a.ignoreReadonly;
                  if ("boolean" != typeof e) throw new TypeError("ignoreReadonly () expects a boolean parameter");
                  return a.ignoreReadonly = e, c
              }, c.options = function(t) {
                  if (0 === arguments.length) return e.extend(!0, {}, a);
                  if (!(t instanceof Object)) throw new TypeError("options() options parameter should be an object");
                  return e.extend(!0, a, t), e.each(a, function(e, t) {
                      if (void 0 === c[e]) throw new TypeError("option " + e + " is not recognized!");
                      c[e](t)
                  }), c
              }, c.date = function(e) {
                  if (0 === arguments.length) return u ? null : r.clone();
                  if (!(null === e || "string" == typeof e || t.isMoment(e) || e instanceof Date)) throw new TypeError("date() parameter must be one of [null, string, moment or Date]");
                  return _(null === e ? null : ne(e)), c
              }, c.format = function(e) {
                  if (0 === arguments.length) return a.format;
                  if ("string" != typeof e && ("boolean" != typeof e || !1 !== e)) throw new TypeError("format() expects a string or boolean:false parameter " + e);
                  return a.format = e, d && fe(), c
              }, c.timeZone = function(e) {
                  if (0 === arguments.length) return a.timeZone;
                  if ("string" != typeof e) throw new TypeError("newZone() expects a string parameter");
                  return a.timeZone = e, c
              }, c.dayViewHeaderFormat = function(e) {
                  if (0 === arguments.length) return a.dayViewHeaderFormat;
                  if ("string" != typeof e) throw new TypeError("dayViewHeaderFormat() expects a string parameter");
                  return a.dayViewHeaderFormat = e, c
              }, c.extraFormats = function(e) {
                  if (0 === arguments.length) return a.extraFormats;
                  if (!1 !== e && !(e instanceof Array)) throw new TypeError("extraFormats() expects an array or false parameter");
                  return a.extraFormats = e, l && fe(), c
              }, c.disabledDates = function(t) {
                  if (0 === arguments.length) return a.disabledDates ? e.extend({}, a.disabledDates) : a.disabledDates;
                  if (!t) return a.disabledDates = !1, $(), c;
                  if (!(t instanceof Array)) throw new TypeError("disabledDates() expects an array parameter");
                  return a.disabledDates = ce(t), a.enabledDates = !1, $(), c
              }, c.enabledDates = function(t) {
                  if (0 === arguments.length) return a.enabledDates ? e.extend({}, a.enabledDates) : a.enabledDates;
                  if (!t) return a.enabledDates = !1, $(), c;
                  if (!(t instanceof Array)) throw new TypeError("enabledDates() expects an array parameter");
                  return a.enabledDates = ce(t), a.disabledDates = !1, $(), c
              }, c.daysOfWeekDisabled = function(e) {
                  if (0 === arguments.length) return a.daysOfWeekDisabled.splice(0);
                  if ("boolean" == typeof e && !e) return a.daysOfWeekDisabled = !1, $(), c;
                  if (!(e instanceof Array)) throw new TypeError("daysOfWeekDisabled() expects an array parameter");
                  if (a.daysOfWeekDisabled = e.reduce(function(e, t) {
                          return (t = parseInt(t, 10)) > 6 || t < 0 || isNaN(t) ? e : (-1 === e.indexOf(t) && e.push(t), e)
                      }, []).sort(), a.useCurrent && !a.keepInvalid) {
                      for (var t = 0; !N(r, "d");) {
                          if (r.add(1, "d"), 31 === t) throw "Tried 31 times to find a valid date";
                          t++
                      }
                      _(r)
                  }
                  return $(), c
              }, c.maxDate = function(e) {
                  if (0 === arguments.length) return a.maxDate ? a.maxDate.clone() : a.maxDate;
                  if ("boolean" == typeof e && !1 === e) return a.maxDate = !1, $(), c;
                  "string" == typeof e && ("now" !== e && "moment" !== e || (e = x()));
                  var t = ne(e);
                  if (!t.isValid()) throw new TypeError("maxDate() Could not parse date parameter: " + e);
                  if (a.minDate && t.isBefore(a.minDate)) throw new TypeError("maxDate() date parameter is before options.minDate: " + t.format(d));
                  return a.maxDate = t, a.useCurrent && !a.keepInvalid && r.isAfter(e) && _(a.maxDate), i.isAfter(t) && (i = t.clone().subtract(a.stepping, "m")), $(), c
              }, c.minDate = function(e) {
                  if (0 === arguments.length) return a.minDate ? a.minDate.clone() : a.minDate;
                  if ("boolean" == typeof e && !1 === e) return a.minDate = !1, $(), c;
                  "string" == typeof e && ("now" !== e && "moment" !== e || (e = x()));
                  var t = ne(e);
                  if (!t.isValid()) throw new TypeError("minDate() Could not parse date parameter: " + e);
                  if (a.maxDate && t.isAfter(a.maxDate)) throw new TypeError("minDate() date parameter is after options.maxDate: " + t.format(d));
                  return a.minDate = t, a.useCurrent && !a.keepInvalid && r.isBefore(e) && _(a.minDate), i.isBefore(t) && (i = t.clone().add(a.stepping, "m")), $(), c
              }, c.defaultDate = function(e) {
                  if (0 === arguments.length) return a.defaultDate ? a.defaultDate.clone() : a.defaultDate;
                  if (!e) return a.defaultDate = !1, c;
                  "string" == typeof e && (e = "now" === e || "moment" === e ? x() : x(e));
                  var t = ne(e);
                  if (!t.isValid()) throw new TypeError("defaultDate() Could not parse date parameter: " + e);
                  if (!N(t)) throw new TypeError("defaultDate() date passed is invalid according to component setup validations");
                  return a.defaultDate = t, (a.defaultDate && a.inline || "" === o.val().trim()) && _(a.defaultDate), c
              }, c.locale = function(e) {
                  if (0 === arguments.length) return a.locale;
                  if (!t.localeData(e)) throw new TypeError("locale() locale " + e + " is not loaded from moment locales!");
                  return a.locale = e, r.locale(a.locale), i.locale(a.locale), d && fe(), h && (ee(), ie()), c
              }, c.stepping = function(e) {
                  return 0 === arguments.length ? a.stepping : (e = parseInt(e, 10), (isNaN(e) || e < 1) && (e = 1), a.stepping = e, c)
              }, c.useCurrent = function(e) {
                  var t = ["year", "month", "day", "hour", "minute"];
                  if (0 === arguments.length) return a.useCurrent;
                  if ("boolean" != typeof e && "string" != typeof e) throw new TypeError("useCurrent() expects a boolean or string parameter");
                  if ("string" == typeof e && -1 === t.indexOf(e.toLowerCase())) throw new TypeError("useCurrent() expects a string parameter of " + t.join(", "));
                  return a.useCurrent = e, c
              }, c.collapse = function(e) {
                  if (0 === arguments.length) return a.collapse;
                  if ("boolean" != typeof e) throw new TypeError("collapse() expects a boolean parameter");
                  return a.collapse === e ? c : (a.collapse = e, h && (ee(), ie()), c)
              }, c.icons = function(t) {
                  if (0 === arguments.length) return e.extend({}, a.icons);
                  if (!(t instanceof Object)) throw new TypeError("icons() expects parameter to be an Object");
                  return e.extend(a.icons, t), h && (ee(), ie()), c
              }, c.tooltips = function(t) {
                  if (0 === arguments.length) return e.extend({}, a.tooltips);
                  if (!(t instanceof Object)) throw new TypeError("tooltips() expects parameter to be an Object");
                  return e.extend(a.tooltips, t), h && (ee(), ie()), c
              }, c.useStrict = function(e) {
                  if (0 === arguments.length) return a.useStrict;
                  if ("boolean" != typeof e) throw new TypeError("useStrict() expects a boolean parameter");
                  return a.useStrict = e, c
              }, c.sideBySide = function(e) {
                  if (0 === arguments.length) return a.sideBySide;
                  if ("boolean" != typeof e) throw new TypeError("sideBySide() expects a boolean parameter");
                  return a.sideBySide = e, h && (ee(), ie()), c
              }, c.viewMode = function(e) {
                  if (0 === arguments.length) return a.viewMode;
                  if ("string" != typeof e) throw new TypeError("viewMode() expects a string parameter");
                  if (-1 === b.indexOf(e)) throw new TypeError("viewMode() parameter must be one of (" + b.join(", ") + ") value");
                  return a.viewMode = e, p = Math.max(b.indexOf(e), m), j(), c
              }, c.toolbarPlacement = function(e) {
                  if (0 === arguments.length) return a.toolbarPlacement;
                  if ("string" != typeof e) throw new TypeError("toolbarPlacement() expects a string parameter");
                  if (-1 === v.indexOf(e)) throw new TypeError("toolbarPlacement() parameter must be one of (" + v.join(", ") + ") value");
                  return a.toolbarPlacement = e, h && (ee(), ie()), c
              }, c.widgetPositioning = function(t) {
                  if (0 === arguments.length) return e.extend({}, a.widgetPositioning);
                  if ("[object Object]" !== {}.toString.call(t)) throw new TypeError("widgetPositioning() expects an object variable");
                  if (t.horizontal) {
                      if ("string" != typeof t.horizontal) throw new TypeError("widgetPositioning() horizontal variable must be a string");
                      if (t.horizontal = t.horizontal.toLowerCase(), -1 === w.indexOf(t.horizontal)) throw new TypeError("widgetPositioning() expects horizontal parameter to be one of (" + w.join(", ") + ")");
                      a.widgetPositioning.horizontal = t.horizontal
                  }
                  if (t.vertical) {
                      if ("string" != typeof t.vertical) throw new TypeError("widgetPositioning() vertical variable must be a string");
                      if (t.vertical = t.vertical.toLowerCase(), -1 === g.indexOf(t.vertical)) throw new TypeError("widgetPositioning() expects vertical parameter to be one of (" + g.join(", ") + ")");
                      a.widgetPositioning.vertical = t.vertical
                  }
                  return $(), c
              }, c.calendarWeeks = function(e) {
                  if (0 === arguments.length) return a.calendarWeeks;
                  if ("boolean" != typeof e) throw new TypeError("calendarWeeks() expects parameter to be a boolean value");
                  return a.calendarWeeks = e, $(), c
              }, c.showTodayButton = function(e) {
                  if (0 === arguments.length) return a.showTodayButton;
                  if ("boolean" != typeof e) throw new TypeError("showTodayButton() expects a boolean parameter");
                  return a.showTodayButton = e, h && (ee(), ie()), c
              }, c.showClear = function(e) {
                  if (0 === arguments.length) return a.showClear;
                  if ("boolean" != typeof e) throw new TypeError("showClear() expects a boolean parameter");
                  return a.showClear = e, h && (ee(), ie()), c
              }, c.widgetParent = function(t) {
                  if (0 === arguments.length) return a.widgetParent;
                  if ("string" == typeof t && (t = e(t)), null !== t && "string" != typeof t && !(t instanceof e)) throw new TypeError("widgetParent() expects a string or a jQuery object parameter");
                  return a.widgetParent = t, h && (ee(), ie()), c
              }, c.keepOpen = function(e) {
                  if (0 === arguments.length) return a.keepOpen;
                  if ("boolean" != typeof e) throw new TypeError("keepOpen() expects a boolean parameter");
                  return a.keepOpen = e, c
              }, c.focusOnShow = function(e) {
                  if (0 === arguments.length) return a.focusOnShow;
                  if ("boolean" != typeof e) throw new TypeError("focusOnShow() expects a boolean parameter");
                  return a.focusOnShow = e, c
              }, c.inline = function(e) {
                  if (0 === arguments.length) return a.inline;
                  if ("boolean" != typeof e) throw new TypeError("inline() expects a boolean parameter");
                  return a.inline = e, c
              }, c.clear = function() {
                  return te(), c
              }, c.keyBinds = function(e) {
                  return 0 === arguments.length ? a.keyBinds : (a.keyBinds = e, c)
              }, c.getMoment = function(e) {
                  return x(e)
              }, c.debug = function(e) {
                  if ("boolean" != typeof e) throw new TypeError("debug() expects a boolean parameter");
                  return a.debug = e, c
              }, c.allowInputToggle = function(e) {
                  if (0 === arguments.length) return a.allowInputToggle;
                  if ("boolean" != typeof e) throw new TypeError("allowInputToggle() expects a boolean parameter");
                  return a.allowInputToggle = e, c
              }, c.showClose = function(e) {
                  if (0 === arguments.length) return a.showClose;
                  if ("boolean" != typeof e) throw new TypeError("showClose() expects a boolean parameter");
                  return a.showClose = e, c
              }, c.keepInvalid = function(e) {
                  if (0 === arguments.length) return a.keepInvalid;
                  if ("boolean" != typeof e) throw new TypeError("keepInvalid() expects a boolean parameter");
                  return a.keepInvalid = e, c
              }, c.datepickerInput = function(e) {
                  if (0 === arguments.length) return a.datepickerInput;
                  if ("string" != typeof e) throw new TypeError("datepickerInput() expects a string parameter");
                  return a.datepickerInput = e, c
              }, c.parseInputDate = function(e) {
                  if (0 === arguments.length) return a.parseInputDate;
                  if ("function" != typeof e) throw new TypeError("parseInputDate() sholud be as function");
                  return a.parseInputDate = e, c
              }, c.disabledTimeIntervals = function(t) {
                  if (0 === arguments.length) return a.disabledTimeIntervals ? e.extend({}, a.disabledTimeIntervals) : a.disabledTimeIntervals;
                  if (!t) return a.disabledTimeIntervals = !1, $(), c;
                  if (!(t instanceof Array)) throw new TypeError("disabledTimeIntervals() expects an array parameter");
                  return a.disabledTimeIntervals = t, $(), c
              }, c.disabledHours = function(t) {
                  if (0 === arguments.length) return a.disabledHours ? e.extend({}, a.disabledHours) : a.disabledHours;
                  if (!t) return a.disabledHours = !1, $(), c;
                  if (!(t instanceof Array)) throw new TypeError("disabledHours() expects an array parameter");
                  if (a.disabledHours = ue(t), a.enabledHours = !1, a.useCurrent && !a.keepInvalid) {
                      for (var n = 0; !N(r, "h");) {
                          if (r.add(1, "h"), 24 === n) throw "Tried 24 times to find a valid date";
                          n++
                      }
                      _(r)
                  }
                  return $(), c
              }, c.enabledHours = function(t) {
                  if (0 === arguments.length) return a.enabledHours ? e.extend({}, a.enabledHours) : a.enabledHours;
                  if (!t) return a.enabledHours = !1, $(), c;
                  if (!(t instanceof Array)) throw new TypeError("enabledHours() expects an array parameter");
                  if (a.enabledHours = ue(t), a.disabledHours = !1, a.useCurrent && !a.keepInvalid) {
                      for (var n = 0; !N(r, "h");) {
                          if (r.add(1, "h"), 24 === n) throw "Tried 24 times to find a valid date";
                          n++
                      }
                      _(r)
                  }
                  return $(), c
              }, c.viewDate = function(e) {
                  if (0 === arguments.length) return i.clone();
                  if (!e) return i = r.clone(), c;
                  if (!("string" == typeof e || t.isMoment(e) || e instanceof Date)) throw new TypeError("viewDate() parameter must be one of [string, moment or Date]");
                  return i = ne(e), B(), c
              }, n.is("input")) o = n;
          else if (0 === (o = n.find(a.datepickerInput)).length) o = n.find("input");
          else if (!o.is("input")) throw new Error('CSS class "' + a.datepickerInput + '" cannot be applied to non input element');
          if (n.hasClass("input-group") && (f = 0 === n.find(".datepickerbutton").length ? n.find(".input-group-addon") : n.find(".datepickerbutton")), !a.inline && !o.is("input")) throw new Error("Could not initialize DateTimePicker without an input element");
          return r = x(), i = r.clone(), e.extend(!0, a, function() {
              var t, r = {};
              return (t = n.is("input") || a.inline ? n.data() : n.find("input").data()).dateOptions && t.dateOptions instanceof Object && (r = e.extend(!0, r, t.dateOptions)), e.each(a, function(e) {
                  var n = "date" + e.charAt(0).toUpperCase() + e.slice(1);
                  void 0 !== t[n] && (r[e] = t[n])
              }), r
          }()), c.options(a), fe(), o.on({
              change: le,
              blur: a.debug ? "" : ee,
              keydown: se,
              keyup: de,
              focus: a.allowInputToggle ? ie : ""
          }), n.is("input") ? o.on({
              focus: ie
          }) : f && (f.on("click", oe), f.on("mousedown", !1)), o.prop("disabled") && c.disable(), o.is("input") && 0 !== o.val().trim().length ? _(ne(o.val().trim())) : a.defaultDate && void 0 === o.attr("placeholder") && _(a.defaultDate), a.inline && ie(), c
      };
      return e.fn.datetimepicker = function(t) {
          t = t || {};
          var a, r = Array.prototype.slice.call(arguments, 1),
              i = !0,
              o = ["destroy", "hide", "show", "toggle"];
          if ("object" == typeof t) return this.each(function() {
              var a, r = e(this);
              r.data("DateTimePicker") || (a = e.extend(!0, {}, e.fn.datetimepicker.defaults, t), r.data("DateTimePicker", n(r, a)))
          });
          if ("string" == typeof t) return this.each(function() {
              var n = e(this).data("DateTimePicker");
              if (!n) throw new Error('bootstrap-datetimepicker("' + t + '") method was called on an element that is not using DateTimePicker');
              a = n[t].apply(n, r), i = a === n
          }), i || e.inArray(t, o) > -1 ? this : a;
          throw new TypeError("Invalid arguments for DateTimePicker: " + t)
      }, e.fn.datetimepicker.defaults = {
          timeZone: "",
          format: !1,
          dayViewHeaderFormat: "MMMM YYYY",
          extraFormats: !1,
          stepping: 1,
          minDate: !1,
          maxDate: !1,
          useCurrent: !0,
          collapse: !0,
          locale: t.locale(),
          defaultDate: !1,
          disabledDates: !1,
          enabledDates: !1,
          icons: {
              time: "glyphicon glyphicon-time",
              date: "glyphicon glyphicon-calendar",
              up: "glyphicon glyphicon-chevron-up",
              down: "glyphicon glyphicon-chevron-down",
              previous: "glyphicon glyphicon-chevron-left",
              next: "glyphicon glyphicon-chevron-right",
              today: "glyphicon glyphicon-screenshot",
              clear: "glyphicon glyphicon-trash",
              close: "glyphicon glyphicon-remove"
          },
          tooltips: {
              today: "Go to today",
              clear: "Clear selection",
              close: "Close the picker",
              selectMonth: "Select Month",
              prevMonth: "Previous Month",
              nextMonth: "Next Month",
              selectYear: "Select Year",
              prevYear: "Previous Year",
              nextYear: "Next Year",
              selectDecade: "Select Decade",
              prevDecade: "Previous Decade",
              nextDecade: "Next Decade",
              prevCentury: "Previous Century",
              nextCentury: "Next Century",
              pickHour: "Pick Hour",
              incrementHour: "Increment Hour",
              decrementHour: "Decrement Hour",
              pickMinute: "Pick Minute",
              incrementMinute: "Increment Minute",
              decrementMinute: "Decrement Minute",
              pickSecond: "Pick Second",
              incrementSecond: "Increment Second",
              decrementSecond: "Decrement Second",
              togglePeriod: "Toggle Period",
              selectTime: "Select Time"
          },
          useStrict: !1,
          sideBySide: !1,
          daysOfWeekDisabled: !1,
          calendarWeeks: !1,
          viewMode: "days",
          toolbarPlacement: "default",
          showTodayButton: !1,
          showClear: !1,
          showClose: !1,
          widgetPositioning: {
              horizontal: "auto",
              vertical: "auto"
          },
          widgetParent: null,
          ignoreReadonly: !1,
          keepOpen: !1,
          focusOnShow: !0,
          inline: !1,
          keepInvalid: !1,
          datepickerInput: ".datepickerinput",
          keyBinds: {
              up: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") ? this.date(t.clone().subtract(7, "d")) : this.date(t.clone().add(this.stepping(), "m"))
                  }
              },
              down: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") ? this.date(t.clone().add(7, "d")) : this.date(t.clone().subtract(this.stepping(), "m"))
                  } else this.show()
              },
              "control up": function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") ? this.date(t.clone().subtract(1, "y")) : this.date(t.clone().add(1, "h"))
                  }
              },
              "control down": function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") ? this.date(t.clone().add(1, "y")) : this.date(t.clone().subtract(1, "h"))
                  }
              },
              left: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") && this.date(t.clone().subtract(1, "d"))
                  }
              },
              right: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") && this.date(t.clone().add(1, "d"))
                  }
              },
              pageUp: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") && this.date(t.clone().subtract(1, "M"))
                  }
              },
              pageDown: function(e) {
                  if (e) {
                      var t = this.date() || this.getMoment();
                      e.find(".datepicker").is(":visible") && this.date(t.clone().add(1, "M"))
                  }
              },
              enter: function() {
                  this.hide()
              },
              escape: function() {
                  this.hide()
              },
              "control space": function(e) {
                  e && e.find(".timepicker").is(":visible") && e.find('.btn[data-action="togglePeriod"]').click()
              },
              t: function() {
                  this.date(this.getMoment())
              },
              delete: function() {
                  this.clear()
              }
          },
          debug: !1,
          allowInputToggle: !1,
          disabledTimeIntervals: !1,
          disabledHours: !1,
          enabledHours: !1,
          viewDate: !1
      }, e.fn.datetimepicker
  });
  //! moment.js
  //! version : 2.14.1
  //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
  //! license : MIT
  //! momentjs.com
  ! function(a, b) {
      "object" == typeof exports && "undefined" != typeof module ? module.exports = b() : "function" == typeof define && define.amd ? define(b) : a.moment = b()
  }(this, function() {
      "use strict";
  
      function a() {
          return md.apply(null, arguments)
      }
      // This is done to register the method called with moment()
      // without creating circular dependencies.
      function b(a) {
          md = a
      }
  
      function c(a) {
          return a instanceof Array || "[object Array]" === Object.prototype.toString.call(a)
      }
  
      function d(a) {
          return "[object Object]" === Object.prototype.toString.call(a)
      }
  
      function e(a) {
          var b;
          for (b in a)
              // even if its not own property I'd still call it non-empty
              return !1;
          return !0
      }
  
      function f(a) {
          return a instanceof Date || "[object Date]" === Object.prototype.toString.call(a)
      }
  
      function g(a, b) {
          var c, d = [];
          for (c = 0; c < a.length; ++c) d.push(b(a[c], c));
          return d
      }
  
      function h(a, b) {
          return Object.prototype.hasOwnProperty.call(a, b)
      }
  
      function i(a, b) {
          for (var c in b) h(b, c) && (a[c] = b[c]);
          return h(b, "toString") && (a.toString = b.toString), h(b, "valueOf") && (a.valueOf = b.valueOf), a
      }
  
      function j(a, b, c, d) {
          return qb(a, b, c, d, !0).utc()
      }
  
      function k() {
          // We need to deep clone this object.
          return {
              empty: !1,
              unusedTokens: [],
              unusedInput: [],
              overflow: -2,
              charsLeftOver: 0,
              nullInput: !1,
              invalidMonth: null,
              invalidFormat: !1,
              userInvalidated: !1,
              iso: !1,
              parsedDateParts: [],
              meridiem: null
          }
      }
  
      function l(a) {
          return null == a._pf && (a._pf = k()), a._pf
      }
  
      function m(a) {
          if (null == a._isValid) {
              var b = l(a),
                  c = nd.call(b.parsedDateParts, function(a) {
                      return null != a
                  });
              a._isValid = !isNaN(a._d.getTime()) && b.overflow < 0 && !b.empty && !b.invalidMonth && !b.invalidWeekday && !b.nullInput && !b.invalidFormat && !b.userInvalidated && (!b.meridiem || b.meridiem && c), a._strict && (a._isValid = a._isValid && 0 === b.charsLeftOver && 0 === b.unusedTokens.length && void 0 === b.bigHour)
          }
          return a._isValid
      }
  
      function n(a) {
          var b = j(NaN);
          return null != a ? i(l(b), a) : l(b).userInvalidated = !0, b
      }
  
      function o(a) {
          return void 0 === a
      }
  
      function p(a, b) {
          var c, d, e;
          if (o(b._isAMomentObject) || (a._isAMomentObject = b._isAMomentObject), o(b._i) || (a._i = b._i), o(b._f) || (a._f = b._f), o(b._l) || (a._l = b._l), o(b._strict) || (a._strict = b._strict), o(b._tzm) || (a._tzm = b._tzm), o(b._isUTC) || (a._isUTC = b._isUTC), o(b._offset) || (a._offset = b._offset), o(b._pf) || (a._pf = l(b)), o(b._locale) || (a._locale = b._locale), od.length > 0)
              for (c in od) d = od[c], e = b[d], o(e) || (a[d] = e);
          return a
      }
      // Moment prototype object
      function q(b) {
          p(this, b), this._d = new Date(null != b._d ? b._d.getTime() : NaN), pd === !1 && (pd = !0, a.updateOffset(this), pd = !1)
      }
  
      function r(a) {
          return a instanceof q || null != a && null != a._isAMomentObject
      }
  
      function s(a) {
          return 0 > a ? Math.ceil(a) || 0 : Math.floor(a)
      }
  
      function t(a) {
          var b = +a,
              c = 0;
          return 0 !== b && isFinite(b) && (c = s(b)), c
      }
      // compare two arrays, return the number of differences
      function u(a, b, c) {
          var d, e = Math.min(a.length, b.length),
              f = Math.abs(a.length - b.length),
              g = 0;
          for (d = 0; e > d; d++)(c && a[d] !== b[d] || !c && t(a[d]) !== t(b[d])) && g++;
          return g + f
      }
  
      function v(b) {
          a.suppressDeprecationWarnings === !1 && "undefined" != typeof console && console.warn && console.warn("Deprecation warning: " + b)
      }
  
      function w(b, c) {
          var d = !0;
          return i(function() {
              return null != a.deprecationHandler && a.deprecationHandler(null, b), d && (v(b + "\nArguments: " + Array.prototype.slice.call(arguments).join(", ") + "\n" + (new Error).stack), d = !1), c.apply(this, arguments)
          }, c)
      }
  
      function x(b, c) {
          null != a.deprecationHandler && a.deprecationHandler(b, c), qd[b] || (v(c), qd[b] = !0)
      }
  
      function y(a) {
          return a instanceof Function || "[object Function]" === Object.prototype.toString.call(a)
      }
  
      function z(a) {
          var b, c;
          for (c in a) b = a[c], y(b) ? this[c] = b : this["_" + c] = b;
          this._config = a,
              // Lenient ordinal parsing accepts just a number in addition to
              // number + (possibly) stuff coming from _ordinalParseLenient.
              this._ordinalParseLenient = new RegExp(this._ordinalParse.source + "|" + /\d{1,2}/.source)
      }
  
      function A(a, b) {
          var c, e = i({}, a);
          for (c in b) h(b, c) && (d(a[c]) && d(b[c]) ? (e[c] = {}, i(e[c], a[c]), i(e[c], b[c])) : null != b[c] ? e[c] = b[c] : delete e[c]);
          for (c in a) h(a, c) && !h(b, c) && d(a[c]) && (
              // make sure changes to properties don't modify parent config
              e[c] = i({}, e[c]));
          return e
      }
  
      function B(a) {
          null != a && this.set(a)
      }
  
      function C(a, b, c) {
          var d = this._calendar[a] || this._calendar.sameElse;
          return y(d) ? d.call(b, c) : d
      }
  
      function D(a) {
          var b = this._longDateFormat[a],
              c = this._longDateFormat[a.toUpperCase()];
          return b || !c ? b : (this._longDateFormat[a] = c.replace(/MMMM|MM|DD|dddd/g, function(a) {
              return a.slice(1)
          }), this._longDateFormat[a])
      }
  
      function E() {
          return this._invalidDate
      }
  
      function F(a) {
          return this._ordinal.replace("%d", a)
      }
  
      function G(a, b, c, d) {
          var e = this._relativeTime[c];
          return y(e) ? e(a, b, c, d) : e.replace(/%d/i, a)
      }
  
      function H(a, b) {
          var c = this._relativeTime[a > 0 ? "future" : "past"];
          return y(c) ? c(b) : c.replace(/%s/i, b)
      }
  
      function I(a, b) {
          var c = a.toLowerCase();
          zd[c] = zd[c + "s"] = zd[b] = a
      }
  
      function J(a) {
          return "string" == typeof a ? zd[a] || zd[a.toLowerCase()] : void 0
      }
  
      function K(a) {
          var b, c, d = {};
          for (c in a) h(a, c) && (b = J(c), b && (d[b] = a[c]));
          return d
      }
  
      function L(a, b) {
          Ad[a] = b
      }
  
      function M(a) {
          var b = [];
          for (var c in a) b.push({
              unit: c,
              priority: Ad[c]
          });
          return b.sort(function(a, b) {
              return a.priority - b.priority
          }), b
      }
  
      function N(b, c) {
          return function(d) {
              return null != d ? (P(this, b, d), a.updateOffset(this, c), this) : O(this, b)
          }
      }
  
      function O(a, b) {
          return a.isValid() ? a._d["get" + (a._isUTC ? "UTC" : "") + b]() : NaN
      }
  
      function P(a, b, c) {
          a.isValid() && a._d["set" + (a._isUTC ? "UTC" : "") + b](c)
      }
      // MOMENTS
      function Q(a) {
          return a = J(a), y(this[a]) ? this[a]() : this
      }
  
      function R(a, b) {
          if ("object" == typeof a) {
              a = K(a);
              for (var c = M(a), d = 0; d < c.length; d++) this[c[d].unit](a[c[d].unit])
          } else if (a = J(a), y(this[a])) return this[a](b);
          return this
      }
  
      function S(a, b, c) {
          var d = "" + Math.abs(a),
              e = b - d.length,
              f = a >= 0;
          return (f ? c ? "+" : "" : "-") + Math.pow(10, Math.max(0, e)).toString().substr(1) + d
      }
      // token:    'M'
      // padded:   ['MM', 2]
      // ordinal:  'Mo'
      // callback: function () { this.month() + 1 }
      function T(a, b, c, d) {
          var e = d;
          "string" == typeof d && (e = function() {
              return this[d]()
          }), a && (Ed[a] = e), b && (Ed[b[0]] = function() {
              return S(e.apply(this, arguments), b[1], b[2])
          }), c && (Ed[c] = function() {
              return this.localeData().ordinal(e.apply(this, arguments), a)
          })
      }
  
      function U(a) {
          return a.match(/\[[\s\S]/) ? a.replace(/^\[|\]$/g, "") : a.replace(/\\/g, "")
      }
  
      function V(a) {
          var b, c, d = a.match(Bd);
          for (b = 0, c = d.length; c > b; b++) Ed[d[b]] ? d[b] = Ed[d[b]] : d[b] = U(d[b]);
          return function(b) {
              var e, f = "";
              for (e = 0; c > e; e++) f += d[e] instanceof Function ? d[e].call(b, a) : d[e];
              return f
          }
      }
      // format date using native date object
      function W(a, b) {
          return a.isValid() ? (b = X(b, a.localeData()), Dd[b] = Dd[b] || V(b), Dd[b](a)) : a.localeData().invalidDate()
      }
  
      function X(a, b) {
          function c(a) {
              return b.longDateFormat(a) || a
          }
          var d = 5;
          for (Cd.lastIndex = 0; d >= 0 && Cd.test(a);) a = a.replace(Cd, c), Cd.lastIndex = 0, d -= 1;
          return a
      }
  
      function Y(a, b, c) {
          Wd[a] = y(b) ? b : function(a, d) {
              return a && c ? c : b
          }
      }
  
      function Z(a, b) {
          return h(Wd, a) ? Wd[a](b._strict, b._locale) : new RegExp($(a))
      }
      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
      function $(a) {
          return _(a.replace("\\", "").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(a, b, c, d, e) {
              return b || c || d || e
          }))
      }
  
      function _(a) {
          return a.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")
      }
  
      function aa(a, b) {
          var c, d = b;
          for ("string" == typeof a && (a = [a]), "number" == typeof b && (d = function(a, c) {
                  c[b] = t(a)
              }), c = 0; c < a.length; c++) Xd[a[c]] = d
      }
  
      function ba(a, b) {
          aa(a, function(a, c, d, e) {
              d._w = d._w || {}, b(a, d._w, d, e)
          })
      }
  
      function ca(a, b, c) {
          null != b && h(Xd, a) && Xd[a](b, c._a, c, a)
      }
  
      function da(a, b) {
          return new Date(Date.UTC(a, b + 1, 0)).getUTCDate()
      }
  
      function ea(a, b) {
          return c(this._months) ? this._months[a.month()] : this._months[(this._months.isFormat || fe).test(b) ? "format" : "standalone"][a.month()]
      }
  
      function fa(a, b) {
          return c(this._monthsShort) ? this._monthsShort[a.month()] : this._monthsShort[fe.test(b) ? "format" : "standalone"][a.month()]
      }
  
      function ga(a, b, c) {
          var d, e, f, g = a.toLocaleLowerCase();
          if (!this._monthsParse)
              for (
                  // this is not used
                  this._monthsParse = [], this._longMonthsParse = [], this._shortMonthsParse = [], d = 0; 12 > d; ++d) f = j([2e3, d]), this._shortMonthsParse[d] = this.monthsShort(f, "").toLocaleLowerCase(), this._longMonthsParse[d] = this.months(f, "").toLocaleLowerCase();
          return c ? "MMM" === b ? (e = sd.call(this._shortMonthsParse, g), -1 !== e ? e : null) : (e = sd.call(this._longMonthsParse, g), -1 !== e ? e : null) : "MMM" === b ? (e = sd.call(this._shortMonthsParse, g), -1 !== e ? e : (e = sd.call(this._longMonthsParse, g), -1 !== e ? e : null)) : (e = sd.call(this._longMonthsParse, g), -1 !== e ? e : (e = sd.call(this._shortMonthsParse, g), -1 !== e ? e : null))
      }
  
      function ha(a, b, c) {
          var d, e, f;
          if (this._monthsParseExact) return ga.call(this, a, b, c);
          // TODO: add sorting
          // Sorting makes sure if one month (or abbr) is a prefix of another
          // see sorting in computeMonthsParse
          for (this._monthsParse || (this._monthsParse = [], this._longMonthsParse = [], this._shortMonthsParse = []), d = 0; 12 > d; d++) {
              // test the regex
              if (e = j([2e3, d]), c && !this._longMonthsParse[d] && (this._longMonthsParse[d] = new RegExp("^" + this.months(e, "").replace(".", "") + "$", "i"), this._shortMonthsParse[d] = new RegExp("^" + this.monthsShort(e, "").replace(".", "") + "$", "i")), c || this._monthsParse[d] || (f = "^" + this.months(e, "") + "|^" + this.monthsShort(e, ""), this._monthsParse[d] = new RegExp(f.replace(".", ""), "i")), c && "MMMM" === b && this._longMonthsParse[d].test(a)) return d;
              if (c && "MMM" === b && this._shortMonthsParse[d].test(a)) return d;
              if (!c && this._monthsParse[d].test(a)) return d
          }
      }
      // MOMENTS
      function ia(a, b) {
          var c;
          if (!a.isValid())
              // No op
              return a;
          if ("string" == typeof b)
              if (/^\d+$/.test(b)) b = t(b);
              else
                  // TODO: Another silent failure?
                  if (b = a.localeData().monthsParse(b), "number" != typeof b) return a;
          return c = Math.min(a.date(), da(a.year(), b)), a._d["set" + (a._isUTC ? "UTC" : "") + "Month"](b, c), a
      }
  
      function ja(b) {
          return null != b ? (ia(this, b), a.updateOffset(this, !0), this) : O(this, "Month")
      }
  
      function ka() {
          return da(this.year(), this.month())
      }
  
      function la(a) {
          return this._monthsParseExact ? (h(this, "_monthsRegex") || na.call(this), a ? this._monthsShortStrictRegex : this._monthsShortRegex) : (h(this, "_monthsShortRegex") || (this._monthsShortRegex = ie), this._monthsShortStrictRegex && a ? this._monthsShortStrictRegex : this._monthsShortRegex)
      }
  
      function ma(a) {
          return this._monthsParseExact ? (h(this, "_monthsRegex") || na.call(this), a ? this._monthsStrictRegex : this._monthsRegex) : (h(this, "_monthsRegex") || (this._monthsRegex = je), this._monthsStrictRegex && a ? this._monthsStrictRegex : this._monthsRegex)
      }
  
      function na() {
          function a(a, b) {
              return b.length - a.length
          }
          var b, c, d = [],
              e = [],
              f = [];
          for (b = 0; 12 > b; b++) c = j([2e3, b]), d.push(this.monthsShort(c, "")), e.push(this.months(c, "")), f.push(this.months(c, "")), f.push(this.monthsShort(c, ""));
          for (
              // Sorting makes sure if one month (or abbr) is a prefix of another it
              // will match the longer piece.
              d.sort(a), e.sort(a), f.sort(a), b = 0; 12 > b; b++) d[b] = _(d[b]), e[b] = _(e[b]);
          for (b = 0; 24 > b; b++) f[b] = _(f[b]);
          this._monthsRegex = new RegExp("^(" + f.join("|") + ")", "i"), this._monthsShortRegex = this._monthsRegex, this._monthsStrictRegex = new RegExp("^(" + e.join("|") + ")", "i"), this._monthsShortStrictRegex = new RegExp("^(" + d.join("|") + ")", "i")
      }
      // HELPERS
      function oa(a) {
          return pa(a) ? 366 : 365
      }
  
      function pa(a) {
          return a % 4 === 0 && a % 100 !== 0 || a % 400 === 0
      }
  
      function qa() {
          return pa(this.year())
      }
  
      function ra(a, b, c, d, e, f, g) {
          //can't just apply() to create a date:
          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
          var h = new Date(a, b, c, d, e, f, g);
          //the date constructor remaps years 0-99 to 1900-1999
          return 100 > a && a >= 0 && isFinite(h.getFullYear()) && h.setFullYear(a), h
      }
  
      function sa(a) {
          var b = new Date(Date.UTC.apply(null, arguments));
          //the Date.UTC function remaps years 0-99 to 1900-1999
          return 100 > a && a >= 0 && isFinite(b.getUTCFullYear()) && b.setUTCFullYear(a), b
      }
      // start-of-first-week - start-of-year
      function ta(a, b, c) {
          var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
              d = 7 + b - c,
              // first-week day local weekday -- which local weekday is fwd
              e = (7 + sa(a, 0, d).getUTCDay() - b) % 7;
          return -e + d - 1
      }
      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
      function ua(a, b, c, d, e) {
          var f, g, h = (7 + c - d) % 7,
              i = ta(a, d, e),
              j = 1 + 7 * (b - 1) + h + i;
          return 0 >= j ? (f = a - 1, g = oa(f) + j) : j > oa(a) ? (f = a + 1, g = j - oa(a)) : (f = a, g = j), {
              year: f,
              dayOfYear: g
          }
      }
  
      function va(a, b, c) {
          var d, e, f = ta(a.year(), b, c),
              g = Math.floor((a.dayOfYear() - f - 1) / 7) + 1;
          return 1 > g ? (e = a.year() - 1, d = g + wa(e, b, c)) : g > wa(a.year(), b, c) ? (d = g - wa(a.year(), b, c), e = a.year() + 1) : (e = a.year(), d = g), {
              week: d,
              year: e
          }
      }
  
      function wa(a, b, c) {
          var d = ta(a, b, c),
              e = ta(a + 1, b, c);
          return (oa(a) - d + e) / 7
      }
      // HELPERS
      // LOCALES
      function xa(a) {
          return va(a, this._week.dow, this._week.doy).week
      }
  
      function ya() {
          return this._week.dow
      }
  
      function za() {
          return this._week.doy
      }
      // MOMENTS
      function Aa(a) {
          var b = this.localeData().week(this);
          return null == a ? b : this.add(7 * (a - b), "d")
      }
  
      function Ba(a) {
          var b = va(this, 1, 4).week;
          return null == a ? b : this.add(7 * (a - b), "d")
      }
      // HELPERS
      function Ca(a, b) {
          return "string" != typeof a ? a : isNaN(a) ? (a = b.weekdaysParse(a), "number" == typeof a ? a : null) : parseInt(a, 10)
      }
  
      function Da(a, b) {
          return "string" == typeof a ? b.weekdaysParse(a) % 7 || 7 : isNaN(a) ? null : a
      }
  
      function Ea(a, b) {
          return c(this._weekdays) ? this._weekdays[a.day()] : this._weekdays[this._weekdays.isFormat.test(b) ? "format" : "standalone"][a.day()]
      }
  
      function Fa(a) {
          return this._weekdaysShort[a.day()]
      }
  
      function Ga(a) {
          return this._weekdaysMin[a.day()]
      }
  
      function Ha(a, b, c) {
          var d, e, f, g = a.toLocaleLowerCase();
          if (!this._weekdaysParse)
              for (this._weekdaysParse = [], this._shortWeekdaysParse = [], this._minWeekdaysParse = [], d = 0; 7 > d; ++d) f = j([2e3, 1]).day(d), this._minWeekdaysParse[d] = this.weekdaysMin(f, "").toLocaleLowerCase(), this._shortWeekdaysParse[d] = this.weekdaysShort(f, "").toLocaleLowerCase(), this._weekdaysParse[d] = this.weekdays(f, "").toLocaleLowerCase();
          return c ? "dddd" === b ? (e = sd.call(this._weekdaysParse, g), -1 !== e ? e : null) : "ddd" === b ? (e = sd.call(this._shortWeekdaysParse, g), -1 !== e ? e : null) : (e = sd.call(this._minWeekdaysParse, g), -1 !== e ? e : null) : "dddd" === b ? (e = sd.call(this._weekdaysParse, g), -1 !== e ? e : (e = sd.call(this._shortWeekdaysParse, g), -1 !== e ? e : (e = sd.call(this._minWeekdaysParse, g), -1 !== e ? e : null))) : "ddd" === b ? (e = sd.call(this._shortWeekdaysParse, g), -1 !== e ? e : (e = sd.call(this._weekdaysParse, g), -1 !== e ? e : (e = sd.call(this._minWeekdaysParse, g), -1 !== e ? e : null))) : (e = sd.call(this._minWeekdaysParse, g), -1 !== e ? e : (e = sd.call(this._weekdaysParse, g), -1 !== e ? e : (e = sd.call(this._shortWeekdaysParse, g), -1 !== e ? e : null)))
      }
  
      function Ia(a, b, c) {
          var d, e, f;
          if (this._weekdaysParseExact) return Ha.call(this, a, b, c);
          for (this._weekdaysParse || (this._weekdaysParse = [], this._minWeekdaysParse = [], this._shortWeekdaysParse = [], this._fullWeekdaysParse = []), d = 0; 7 > d; d++) {
              // test the regex
              if (e = j([2e3, 1]).day(d), c && !this._fullWeekdaysParse[d] && (this._fullWeekdaysParse[d] = new RegExp("^" + this.weekdays(e, "").replace(".", ".?") + "$", "i"), this._shortWeekdaysParse[d] = new RegExp("^" + this.weekdaysShort(e, "").replace(".", ".?") + "$", "i"), this._minWeekdaysParse[d] = new RegExp("^" + this.weekdaysMin(e, "").replace(".", ".?") + "$", "i")), this._weekdaysParse[d] || (f = "^" + this.weekdays(e, "") + "|^" + this.weekdaysShort(e, "") + "|^" + this.weekdaysMin(e, ""), this._weekdaysParse[d] = new RegExp(f.replace(".", ""), "i")), c && "dddd" === b && this._fullWeekdaysParse[d].test(a)) return d;
              if (c && "ddd" === b && this._shortWeekdaysParse[d].test(a)) return d;
              if (c && "dd" === b && this._minWeekdaysParse[d].test(a)) return d;
              if (!c && this._weekdaysParse[d].test(a)) return d
          }
      }
      // MOMENTS
      function Ja(a) {
          if (!this.isValid()) return null != a ? this : NaN;
          var b = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
          return null != a ? (a = Ca(a, this.localeData()), this.add(a - b, "d")) : b
      }
  
      function Ka(a) {
          if (!this.isValid()) return null != a ? this : NaN;
          var b = (this.day() + 7 - this.localeData()._week.dow) % 7;
          return null == a ? b : this.add(a - b, "d")
      }
  
      function La(a) {
          if (!this.isValid()) return null != a ? this : NaN;
          // behaves the same as moment#day except
          // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
          // as a setter, sunday should belong to the previous week.
          if (null != a) {
              var b = Da(a, this.localeData());
              return this.day(this.day() % 7 ? b : b - 7)
          }
          return this.day() || 7
      }
  
      function Ma(a) {
          return this._weekdaysParseExact ? (h(this, "_weekdaysRegex") || Pa.call(this), a ? this._weekdaysStrictRegex : this._weekdaysRegex) : (h(this, "_weekdaysRegex") || (this._weekdaysRegex = pe), this._weekdaysStrictRegex && a ? this._weekdaysStrictRegex : this._weekdaysRegex)
      }
  
      function Na(a) {
          return this._weekdaysParseExact ? (h(this, "_weekdaysRegex") || Pa.call(this), a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex) : (h(this, "_weekdaysShortRegex") || (this._weekdaysShortRegex = qe), this._weekdaysShortStrictRegex && a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex)
      }
  
      function Oa(a) {
          return this._weekdaysParseExact ? (h(this, "_weekdaysRegex") || Pa.call(this), a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex) : (h(this, "_weekdaysMinRegex") || (this._weekdaysMinRegex = re), this._weekdaysMinStrictRegex && a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex)
      }
  
      function Pa() {
          function a(a, b) {
              return b.length - a.length
          }
          var b, c, d, e, f, g = [],
              h = [],
              i = [],
              k = [];
          for (b = 0; 7 > b; b++) c = j([2e3, 1]).day(b), d = this.weekdaysMin(c, ""), e = this.weekdaysShort(c, ""), f = this.weekdays(c, ""), g.push(d), h.push(e), i.push(f), k.push(d), k.push(e), k.push(f);
          for (
              // Sorting makes sure if one weekday (or abbr) is a prefix of another it
              // will match the longer piece.
              g.sort(a), h.sort(a), i.sort(a), k.sort(a), b = 0; 7 > b; b++) h[b] = _(h[b]), i[b] = _(i[b]), k[b] = _(k[b]);
          this._weekdaysRegex = new RegExp("^(" + k.join("|") + ")", "i"), this._weekdaysShortRegex = this._weekdaysRegex, this._weekdaysMinRegex = this._weekdaysRegex, this._weekdaysStrictRegex = new RegExp("^(" + i.join("|") + ")", "i"), this._weekdaysShortStrictRegex = new RegExp("^(" + h.join("|") + ")", "i"), this._weekdaysMinStrictRegex = new RegExp("^(" + g.join("|") + ")", "i")
      }
      // FORMATTING
      function Qa() {
          return this.hours() % 12 || 12
      }
  
      function Ra() {
          return this.hours() || 24
      }
  
      function Sa(a, b) {
          T(a, 0, 0, function() {
              return this.localeData().meridiem(this.hours(), this.minutes(), b)
          })
      }
      // PARSING
      function Ta(a, b) {
          return b._meridiemParse
      }
      // LOCALES
      function Ua(a) {
          // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
          // Using charAt should be more compatible.
          return "p" === (a + "").toLowerCase().charAt(0)
      }
  
      function Va(a, b, c) {
          return a > 11 ? c ? "pm" : "PM" : c ? "am" : "AM"
      }
  
      function Wa(a) {
          return a ? a.toLowerCase().replace("_", "-") : a
      }
      // pick the locale from the array
      // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
      // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
      function Xa(a) {
          for (var b, c, d, e, f = 0; f < a.length;) {
              for (e = Wa(a[f]).split("-"), b = e.length, c = Wa(a[f + 1]), c = c ? c.split("-") : null; b > 0;) {
                  if (d = Ya(e.slice(0, b).join("-"))) return d;
                  if (c && c.length >= b && u(e, c, !0) >= b - 1)
                      //the next array item is better than a shallower substring of this one
                      break;
                  b--
              }
              f++
          }
          return null
      }
  
      function Ya(a) {
          var b = null;
          // TODO: Find a better way to register and load all the locales in Node
          if (!we[a] && "undefined" != typeof module && module && module.exports) try {
              b = se._abbr, require("./locale/" + a),
                  // because defineLocale currently also sets the global locale, we
                  // want to undo that for lazy loaded locales
                  Za(b)
          } catch (c) {}
          return we[a]
      }
      // This function will load locale and then set the global locale.  If
      // no arguments are passed in, it will simply return the current global
      // locale key.
      function Za(a, b) {
          var c;
          // moment.duration._locale = moment._locale = data;
          return a && (c = o(b) ? ab(a) : $a(a, b), c && (se = c)), se._abbr
      }
  
      function $a(a, b) {
          if (null !== b) {
              var c = ve;
              // treat as if there is no base config
              // backwards compat for now: also set the locale
              return b.abbr = a, null != we[a] ? (x("defineLocaleOverride", "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."), c = we[a]._config) : null != b.parentLocale && (null != we[b.parentLocale] ? c = we[b.parentLocale]._config : x("parentLocaleUndefined", "specified parentLocale is not defined yet. See http://momentjs.com/guides/#/warnings/parent-locale/")), we[a] = new B(A(c, b)), Za(a), we[a]
          }
          // useful for testing
          return delete we[a], null
      }
  
      function _a(a, b) {
          if (null != b) {
              var c, d = ve;
              // MERGE
              null != we[a] && (d = we[a]._config), b = A(d, b), c = new B(b), c.parentLocale = we[a], we[a] = c,
                  // backwards compat for now: also set the locale
                  Za(a)
          } else
              // pass null for config to unupdate, useful for tests
              null != we[a] && (null != we[a].parentLocale ? we[a] = we[a].parentLocale : null != we[a] && delete we[a]);
          return we[a]
      }
      // returns locale data
      function ab(a) {
          var b;
          if (a && a._locale && a._locale._abbr && (a = a._locale._abbr), !a) return se;
          if (!c(a)) {
              if (b = Ya(a)) return b;
              a = [a]
          }
          return Xa(a)
      }
  
      function bb() {
          return rd(we)
      }
  
      function cb(a) {
          var b, c = a._a;
          return c && -2 === l(a).overflow && (b = c[Zd] < 0 || c[Zd] > 11 ? Zd : c[$d] < 1 || c[$d] > da(c[Yd], c[Zd]) ? $d : c[_d] < 0 || c[_d] > 24 || 24 === c[_d] && (0 !== c[ae] || 0 !== c[be] || 0 !== c[ce]) ? _d : c[ae] < 0 || c[ae] > 59 ? ae : c[be] < 0 || c[be] > 59 ? be : c[ce] < 0 || c[ce] > 999 ? ce : -1, l(a)._overflowDayOfYear && (Yd > b || b > $d) && (b = $d), l(a)._overflowWeeks && -1 === b && (b = de), l(a)._overflowWeekday && -1 === b && (b = ee), l(a).overflow = b), a
      }
      // date from iso format
      function db(a) {
          var b, c, d, e, f, g, h = a._i,
              i = xe.exec(h) || ye.exec(h);
          if (i) {
              for (l(a).iso = !0, b = 0, c = Ae.length; c > b; b++)
                  if (Ae[b][1].exec(i[1])) {
                      e = Ae[b][0], d = Ae[b][2] !== !1;
                      break
                  }
              if (null == e) return void(a._isValid = !1);
              if (i[3]) {
                  for (b = 0, c = Be.length; c > b; b++)
                      if (Be[b][1].exec(i[3])) {
                          // match[2] should be 'T' or space
                          f = (i[2] || " ") + Be[b][0];
                          break
                      }
                  if (null == f) return void(a._isValid = !1)
              }
              if (!d && null != f) return void(a._isValid = !1);
              if (i[4]) {
                  if (!ze.exec(i[4])) return void(a._isValid = !1);
                  g = "Z"
              }
              a._f = e + (f || "") + (g || ""), jb(a)
          } else a._isValid = !1
      }
      // date from iso format or fallback
      function eb(b) {
          var c = Ce.exec(b._i);
          return null !== c ? void(b._d = new Date(+c[1])) : (db(b), void(b._isValid === !1 && (delete b._isValid, a.createFromInputFallback(b))))
      }
      // Pick the first defined of two or three arguments.
      function fb(a, b, c) {
          return null != a ? a : null != b ? b : c
      }
  
      function gb(b) {
          // hooks is actually the exported moment object
          var c = new Date(a.now());
          return b._useUTC ? [c.getUTCFullYear(), c.getUTCMonth(), c.getUTCDate()] : [c.getFullYear(), c.getMonth(), c.getDate()]
      }
      // convert an array to a date.
      // the array should mirror the parameters below
      // note: all values past the year are optional and will default to the lowest possible value.
      // [year, month, day , hour, minute, second, millisecond]
      function hb(a) {
          var b, c, d, e, f = [];
          if (!a._d) {
              // Default to current date.
              // * if no year, month, day of month are given, default to today
              // * if day of month is given, default month and year
              // * if month is given, default only year
              // * if year is given, don't default anything
              for (d = gb(a), a._w && null == a._a[$d] && null == a._a[Zd] && ib(a), a._dayOfYear && (e = fb(a._a[Yd], d[Yd]), a._dayOfYear > oa(e) && (l(a)._overflowDayOfYear = !0), c = sa(e, 0, a._dayOfYear), a._a[Zd] = c.getUTCMonth(), a._a[$d] = c.getUTCDate()), b = 0; 3 > b && null == a._a[b]; ++b) a._a[b] = f[b] = d[b];
              // Zero out whatever was not defaulted, including time
              for (; 7 > b; b++) a._a[b] = f[b] = null == a._a[b] ? 2 === b ? 1 : 0 : a._a[b];
              // Check for 24:00:00.000
              24 === a._a[_d] && 0 === a._a[ae] && 0 === a._a[be] && 0 === a._a[ce] && (a._nextDay = !0, a._a[_d] = 0), a._d = (a._useUTC ? sa : ra).apply(null, f),
                  // Apply timezone offset from input. The actual utcOffset can be changed
                  // with parseZone.
                  null != a._tzm && a._d.setUTCMinutes(a._d.getUTCMinutes() - a._tzm), a._nextDay && (a._a[_d] = 24)
          }
      }
  
      function ib(a) {
          var b, c, d, e, f, g, h, i;
          b = a._w, null != b.GG || null != b.W || null != b.E ? (f = 1, g = 4, c = fb(b.GG, a._a[Yd], va(rb(), 1, 4).year), d = fb(b.W, 1), e = fb(b.E, 1), (1 > e || e > 7) && (i = !0)) : (f = a._locale._week.dow, g = a._locale._week.doy, c = fb(b.gg, a._a[Yd], va(rb(), f, g).year), d = fb(b.w, 1), null != b.d ? (e = b.d, (0 > e || e > 6) && (i = !0)) : null != b.e ? (e = b.e + f, (b.e < 0 || b.e > 6) && (i = !0)) : e = f), 1 > d || d > wa(c, f, g) ? l(a)._overflowWeeks = !0 : null != i ? l(a)._overflowWeekday = !0 : (h = ua(c, d, e, f, g), a._a[Yd] = h.year, a._dayOfYear = h.dayOfYear)
      }
      // date from string and format string
      function jb(b) {
          // TODO: Move this to another part of the creation flow to prevent circular deps
          if (b._f === a.ISO_8601) return void db(b);
          b._a = [], l(b).empty = !0;
          // This array is used to make a Date, either with `new Date` or `Date.UTC`
          var c, d, e, f, g, h = "" + b._i,
              i = h.length,
              j = 0;
          for (e = X(b._f, b._locale).match(Bd) || [], c = 0; c < e.length; c++) f = e[c], d = (h.match(Z(f, b)) || [])[0], d && (g = h.substr(0, h.indexOf(d)), g.length > 0 && l(b).unusedInput.push(g), h = h.slice(h.indexOf(d) + d.length), j += d.length), Ed[f] ? (d ? l(b).empty = !1 : l(b).unusedTokens.push(f), ca(f, d, b)) : b._strict && !d && l(b).unusedTokens.push(f);
          // add remaining unparsed input length to the string
          l(b).charsLeftOver = i - j, h.length > 0 && l(b).unusedInput.push(h),
              // clear _12h flag if hour is <= 12
              b._a[_d] <= 12 && l(b).bigHour === !0 && b._a[_d] > 0 && (l(b).bigHour = void 0), l(b).parsedDateParts = b._a.slice(0), l(b).meridiem = b._meridiem,
              // handle meridiem
              b._a[_d] = kb(b._locale, b._a[_d], b._meridiem), hb(b), cb(b)
      }
  
      function kb(a, b, c) {
          var d;
          // Fallback
          return null == c ? b : null != a.meridiemHour ? a.meridiemHour(b, c) : null != a.isPM ? (d = a.isPM(c), d && 12 > b && (b += 12), d || 12 !== b || (b = 0), b) : b
      }
      // date from string and array of format strings
      function lb(a) {
          var b, c, d, e, f;
          if (0 === a._f.length) return l(a).invalidFormat = !0, void(a._d = new Date(NaN));
          for (e = 0; e < a._f.length; e++) f = 0, b = p({}, a), null != a._useUTC && (b._useUTC = a._useUTC), b._f = a._f[e], jb(b), m(b) && (f += l(b).charsLeftOver, f += 10 * l(b).unusedTokens.length, l(b).score = f, (null == d || d > f) && (d = f, c = b));
          i(a, c || b)
      }
  
      function mb(a) {
          if (!a._d) {
              var b = K(a._i);
              a._a = g([b.year, b.month, b.day || b.date, b.hour, b.minute, b.second, b.millisecond], function(a) {
                  return a && parseInt(a, 10)
              }), hb(a)
          }
      }
  
      function nb(a) {
          var b = new q(cb(ob(a)));
          // Adding is smart enough around DST
          return b._nextDay && (b.add(1, "d"), b._nextDay = void 0), b
      }
  
      function ob(a) {
          var b = a._i,
              d = a._f;
          return a._locale = a._locale || ab(a._l), null === b || void 0 === d && "" === b ? n({
              nullInput: !0
          }) : ("string" == typeof b && (a._i = b = a._locale.preparse(b)), r(b) ? new q(cb(b)) : (c(d) ? lb(a) : f(b) ? a._d = b : d ? jb(a) : pb(a), m(a) || (a._d = null), a))
      }
  
      function pb(b) {
          var d = b._i;
          void 0 === d ? b._d = new Date(a.now()) : f(d) ? b._d = new Date(d.valueOf()) : "string" == typeof d ? eb(b) : c(d) ? (b._a = g(d.slice(0), function(a) {
                  return parseInt(a, 10)
              }), hb(b)) : "object" == typeof d ? mb(b) : "number" == typeof d ?
              // from milliseconds
              b._d = new Date(d) : a.createFromInputFallback(b)
      }
  
      function qb(a, b, f, g, h) {
          var i = {};
          // object construction must be done this way.
          // https://github.com/moment/moment/issues/1423
          return "boolean" == typeof f && (g = f, f = void 0), (d(a) && e(a) || c(a) && 0 === a.length) && (a = void 0), i._isAMomentObject = !0, i._useUTC = i._isUTC = h, i._l = f, i._i = a, i._f = b, i._strict = g, nb(i)
      }
  
      function rb(a, b, c, d) {
          return qb(a, b, c, d, !1)
      }
      // Pick a moment m from moments so that m[fn](other) is true for all
      // other. This relies on the function fn to be transitive.
      //
      // moments should either be an array of moment objects or an array, whose
      // first element is an array of moment objects.
      function sb(a, b) {
          var d, e;
          if (1 === b.length && c(b[0]) && (b = b[0]), !b.length) return rb();
          for (d = b[0], e = 1; e < b.length; ++e) b[e].isValid() && !b[e][a](d) || (d = b[e]);
          return d
      }
      // TODO: Use [].sort instead?
      function tb() {
          var a = [].slice.call(arguments, 0);
          return sb("isBefore", a)
      }
  
      function ub() {
          var a = [].slice.call(arguments, 0);
          return sb("isAfter", a)
      }
  
      function vb(a) {
          var b = K(a),
              c = b.year || 0,
              d = b.quarter || 0,
              e = b.month || 0,
              f = b.week || 0,
              g = b.day || 0,
              h = b.hour || 0,
              i = b.minute || 0,
              j = b.second || 0,
              k = b.millisecond || 0;
          // representation for dateAddRemove
          this._milliseconds = +k + 1e3 * j + // 1000
              6e4 * i + // 1000 * 60
              1e3 * h * 60 * 60, //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
              // Because of dateAddRemove treats 24 hours as different from a
              // day when working around DST, we need to store them separately
              this._days = +g + 7 * f,
              // It is impossible translate months into days without knowing
              // which months you are are talking about, so we have to store
              // it separately.
              this._months = +e + 3 * d + 12 * c, this._data = {}, this._locale = ab(), this._bubble()
      }
  
      function wb(a) {
          return a instanceof vb
      }
      // FORMATTING
      function xb(a, b) {
          T(a, 0, 0, function() {
              var a = this.utcOffset(),
                  c = "+";
              return 0 > a && (a = -a, c = "-"), c + S(~~(a / 60), 2) + b + S(~~a % 60, 2)
          })
      }
  
      function yb(a, b) {
          var c = (b || "").match(a) || [],
              d = c[c.length - 1] || [],
              e = (d + "").match(Ge) || ["-", 0, 0],
              f = +(60 * e[1]) + t(e[2]);
          return "+" === e[0] ? f : -f
      }
      // Return a moment from input, that is local/utc/zone equivalent to model.
      function zb(b, c) {
          var d, e;
          // Use low-level api, because this fn is low-level api.
          return c._isUTC ? (d = c.clone(), e = (r(b) || f(b) ? b.valueOf() : rb(b).valueOf()) - d.valueOf(), d._d.setTime(d._d.valueOf() + e), a.updateOffset(d, !1), d) : rb(b).local()
      }
  
      function Ab(a) {
          // On Firefox.24 Date#getTimezoneOffset returns a floating point.
          // https://github.com/moment/moment/pull/1871
          return 15 * -Math.round(a._d.getTimezoneOffset() / 15)
      }
      // MOMENTS
      // keepLocalTime = true means only change the timezone, without
      // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
      // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
      // +0200, so we adjust the time as needed, to be valid.
      //
      // Keeping the time actually adds/subtracts (one hour)
      // from the actual represented time. That is why we call updateOffset
      // a second time. In case it wants us to change the offset again
      // _changeInProgress == true case, then we have to adjust, because
      // there is no such time in the given timezone.
      function Bb(b, c) {
          var d, e = this._offset || 0;
          return this.isValid() ? null != b ? ("string" == typeof b ? b = yb(Td, b) : Math.abs(b) < 16 && (b = 60 * b), !this._isUTC && c && (d = Ab(this)), this._offset = b, this._isUTC = !0, null != d && this.add(d, "m"), e !== b && (!c || this._changeInProgress ? Sb(this, Mb(b - e, "m"), 1, !1) : this._changeInProgress || (this._changeInProgress = !0, a.updateOffset(this, !0), this._changeInProgress = null)), this) : this._isUTC ? e : Ab(this) : null != b ? this : NaN
      }
  
      function Cb(a, b) {
          return null != a ? ("string" != typeof a && (a = -a), this.utcOffset(a, b), this) : -this.utcOffset()
      }
  
      function Db(a) {
          return this.utcOffset(0, a)
      }
  
      function Eb(a) {
          return this._isUTC && (this.utcOffset(0, a), this._isUTC = !1, a && this.subtract(Ab(this), "m")), this
      }
  
      function Fb() {
          return this._tzm ? this.utcOffset(this._tzm) : "string" == typeof this._i && this.utcOffset(yb(Sd, this._i)), this
      }
  
      function Gb(a) {
          return this.isValid() ? (a = a ? rb(a).utcOffset() : 0, (this.utcOffset() - a) % 60 === 0) : !1
      }
  
      function Hb() {
          return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset()
      }
  
      function Ib() {
          if (!o(this._isDSTShifted)) return this._isDSTShifted;
          var a = {};
          if (p(a, this), a = ob(a), a._a) {
              var b = a._isUTC ? j(a._a) : rb(a._a);
              this._isDSTShifted = this.isValid() && u(a._a, b.toArray()) > 0
          } else this._isDSTShifted = !1;
          return this._isDSTShifted
      }
  
      function Jb() {
          return this.isValid() ? !this._isUTC : !1
      }
  
      function Kb() {
          return this.isValid() ? this._isUTC : !1
      }
  
      function Lb() {
          return this.isValid() ? this._isUTC && 0 === this._offset : !1
      }
  
      function Mb(a, b) {
          var c, d, e, f = a,
              // matching against regexp is expensive, do it on demand
              g = null; // checks for null or undefined
          return wb(a) ? f = {
              ms: a._milliseconds,
              d: a._days,
              M: a._months
          } : "number" == typeof a ? (f = {}, b ? f[b] = a : f.milliseconds = a) : (g = He.exec(a)) ? (c = "-" === g[1] ? -1 : 1, f = {
              y: 0,
              d: t(g[$d]) * c,
              h: t(g[_d]) * c,
              m: t(g[ae]) * c,
              s: t(g[be]) * c,
              ms: t(g[ce]) * c
          }) : (g = Ie.exec(a)) ? (c = "-" === g[1] ? -1 : 1, f = {
              y: Nb(g[2], c),
              M: Nb(g[3], c),
              w: Nb(g[4], c),
              d: Nb(g[5], c),
              h: Nb(g[6], c),
              m: Nb(g[7], c),
              s: Nb(g[8], c)
          }) : null == f ? f = {} : "object" == typeof f && ("from" in f || "to" in f) && (e = Pb(rb(f.from), rb(f.to)), f = {}, f.ms = e.milliseconds, f.M = e.months), d = new vb(f), wb(a) && h(a, "_locale") && (d._locale = a._locale), d
      }
  
      function Nb(a, b) {
          // We'd normally use ~~inp for this, but unfortunately it also
          // converts floats to ints.
          // inp may be undefined, so careful calling replace on it.
          var c = a && parseFloat(a.replace(",", "."));
          // apply sign while we're at it
          return (isNaN(c) ? 0 : c) * b
      }
  
      function Ob(a, b) {
          var c = {
              milliseconds: 0,
              months: 0
          };
          return c.months = b.month() - a.month() + 12 * (b.year() - a.year()), a.clone().add(c.months, "M").isAfter(b) && --c.months, c.milliseconds = +b - +a.clone().add(c.months, "M"), c
      }
  
      function Pb(a, b) {
          var c;
          return a.isValid() && b.isValid() ? (b = zb(b, a), a.isBefore(b) ? c = Ob(a, b) : (c = Ob(b, a), c.milliseconds = -c.milliseconds, c.months = -c.months), c) : {
              milliseconds: 0,
              months: 0
          }
      }
  
      function Qb(a) {
          return 0 > a ? -1 * Math.round(-1 * a) : Math.round(a)
      }
      // TODO: remove 'name' arg after deprecation is removed
      function Rb(a, b) {
          return function(c, d) {
              var e, f;
              //invert the arguments, but complain about it
              return null === d || isNaN(+d) || (x(b, "moment()." + b + "(period, number) is deprecated. Please use moment()." + b + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."), f = c, c = d, d = f), c = "string" == typeof c ? +c : c, e = Mb(c, d), Sb(this, e, a), this
          }
      }
  
      function Sb(b, c, d, e) {
          var f = c._milliseconds,
              g = Qb(c._days),
              h = Qb(c._months);
          b.isValid() && (e = null == e ? !0 : e, f && b._d.setTime(b._d.valueOf() + f * d), g && P(b, "Date", O(b, "Date") + g * d), h && ia(b, O(b, "Month") + h * d), e && a.updateOffset(b, g || h))
      }
  
      function Tb(a, b) {
          var c = a.diff(b, "days", !0);
          return -6 > c ? "sameElse" : -1 > c ? "lastWeek" : 0 > c ? "lastDay" : 1 > c ? "sameDay" : 2 > c ? "nextDay" : 7 > c ? "nextWeek" : "sameElse"
      }
  
      function Ub(b, c) {
          // We want to compare the start of today, vs this.
          // Getting start-of-today depends on whether we're local/utc/offset or not.
          var d = b || rb(),
              e = zb(d, this).startOf("day"),
              f = a.calendarFormat(this, e) || "sameElse",
              g = c && (y(c[f]) ? c[f].call(this, d) : c[f]);
          return this.format(g || this.localeData().calendar(f, this, rb(d)))
      }
  
      function Vb() {
          return new q(this)
      }
  
      function Wb(a, b) {
          var c = r(a) ? a : rb(a);
          return this.isValid() && c.isValid() ? (b = J(o(b) ? "millisecond" : b), "millisecond" === b ? this.valueOf() > c.valueOf() : c.valueOf() < this.clone().startOf(b).valueOf()) : !1
      }
  
      function Xb(a, b) {
          var c = r(a) ? a : rb(a);
          return this.isValid() && c.isValid() ? (b = J(o(b) ? "millisecond" : b), "millisecond" === b ? this.valueOf() < c.valueOf() : this.clone().endOf(b).valueOf() < c.valueOf()) : !1
      }
  
      function Yb(a, b, c, d) {
          return d = d || "()", ("(" === d[0] ? this.isAfter(a, c) : !this.isBefore(a, c)) && (")" === d[1] ? this.isBefore(b, c) : !this.isAfter(b, c))
      }
  
      function Zb(a, b) {
          var c, d = r(a) ? a : rb(a);
          return this.isValid() && d.isValid() ? (b = J(b || "millisecond"), "millisecond" === b ? this.valueOf() === d.valueOf() : (c = d.valueOf(), this.clone().startOf(b).valueOf() <= c && c <= this.clone().endOf(b).valueOf())) : !1
      }
  
      function $b(a, b) {
          return this.isSame(a, b) || this.isAfter(a, b)
      }
  
      function _b(a, b) {
          return this.isSame(a, b) || this.isBefore(a, b)
      }
  
      function ac(a, b, c) {
          var d, e, f, g; // 1000
          // 1000 * 60
          // 1000 * 60 * 60
          // 1000 * 60 * 60 * 24, negate dst
          // 1000 * 60 * 60 * 24 * 7, negate dst
          return this.isValid() ? (d = zb(a, this), d.isValid() ? (e = 6e4 * (d.utcOffset() - this.utcOffset()), b = J(b), "year" === b || "month" === b || "quarter" === b ? (g = bc(this, d), "quarter" === b ? g /= 3 : "year" === b && (g /= 12)) : (f = this - d, g = "second" === b ? f / 1e3 : "minute" === b ? f / 6e4 : "hour" === b ? f / 36e5 : "day" === b ? (f - e) / 864e5 : "week" === b ? (f - e) / 6048e5 : f), c ? g : s(g)) : NaN) : NaN
      }
  
      function bc(a, b) {
          // difference in months
          var c, d, e = 12 * (b.year() - a.year()) + (b.month() - a.month()),
              // b is in (anchor - 1 month, anchor + 1 month)
              f = a.clone().add(e, "months");
          //check for negative zero, return zero if negative zero
          // linear across the month
          // linear across the month
          return 0 > b - f ? (c = a.clone().add(e - 1, "months"), d = (b - f) / (f - c)) : (c = a.clone().add(e + 1, "months"), d = (b - f) / (c - f)), -(e + d) || 0
      }
  
      function cc() {
          return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")
      }
  
      function dc() {
          var a = this.clone().utc();
          return 0 < a.year() && a.year() <= 9999 ? y(Date.prototype.toISOString) ? this.toDate().toISOString() : W(a, "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]") : W(a, "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]")
      }
  
      function ec(b) {
          b || (b = this.isUtc() ? a.defaultFormatUtc : a.defaultFormat);
          var c = W(this, b);
          return this.localeData().postformat(c)
      }
  
      function fc(a, b) {
          return this.isValid() && (r(a) && a.isValid() || rb(a).isValid()) ? Mb({
              to: this,
              from: a
          }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
      }
  
      function gc(a) {
          return this.from(rb(), a)
      }
  
      function hc(a, b) {
          return this.isValid() && (r(a) && a.isValid() || rb(a).isValid()) ? Mb({
              from: this,
              to: a
          }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
      }
  
      function ic(a) {
          return this.to(rb(), a)
      }
      // If passed a locale key, it will set the locale for this
      // instance.  Otherwise, it will return the locale configuration
      // variables for this instance.
      function jc(a) {
          var b;
          return void 0 === a ? this._locale._abbr : (b = ab(a), null != b && (this._locale = b), this)
      }
  
      function kc() {
          return this._locale
      }
  
      function lc(a) {
          // the following switch intentionally omits break keywords
          // to utilize falling through the cases.
          switch (a = J(a)) {
              case "year":
                  this.month(0); /* falls through */
              case "quarter":
              case "month":
                  this.date(1); /* falls through */
              case "week":
              case "isoWeek":
              case "day":
              case "date":
                  this.hours(0); /* falls through */
              case "hour":
                  this.minutes(0); /* falls through */
              case "minute":
                  this.seconds(0); /* falls through */
              case "second":
                  this.milliseconds(0)
          }
          // weeks are a special case
          // quarters are also special
          return "week" === a && this.weekday(0), "isoWeek" === a && this.isoWeekday(1), "quarter" === a && this.month(3 * Math.floor(this.month() / 3)), this
      }
  
      function mc(a) {
          // 'date' is an alias for 'day', so it should be considered as such.
          return a = J(a), void 0 === a || "millisecond" === a ? this : ("date" === a && (a = "day"), this.startOf(a).add(1, "isoWeek" === a ? "week" : a).subtract(1, "ms"))
      }
  
      function nc() {
          return this._d.valueOf() - 6e4 * (this._offset || 0)
      }
  
      function oc() {
          return Math.floor(this.valueOf() / 1e3)
      }
  
      function pc() {
          return new Date(this.valueOf())
      }
  
      function qc() {
          var a = this;
          return [a.year(), a.month(), a.date(), a.hour(), a.minute(), a.second(), a.millisecond()]
      }
  
      function rc() {
          var a = this;
          return {
              years: a.year(),
              months: a.month(),
              date: a.date(),
              hours: a.hours(),
              minutes: a.minutes(),
              seconds: a.seconds(),
              milliseconds: a.milliseconds()
          }
      }
  
      function sc() {
          // new Date(NaN).toJSON() === null
          return this.isValid() ? this.toISOString() : null
      }
  
      function tc() {
          return m(this)
      }
  
      function uc() {
          return i({}, l(this))
      }
  
      function vc() {
          return l(this).overflow
      }
  
      function wc() {
          return {
              input: this._i,
              format: this._f,
              locale: this._locale,
              isUTC: this._isUTC,
              strict: this._strict
          }
      }
  
      function xc(a, b) {
          T(0, [a, a.length], 0, b)
      }
      // MOMENTS
      function yc(a) {
          return Cc.call(this, a, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy)
      }
  
      function zc(a) {
          return Cc.call(this, a, this.isoWeek(), this.isoWeekday(), 1, 4)
      }
  
      function Ac() {
          return wa(this.year(), 1, 4)
      }
  
      function Bc() {
          var a = this.localeData()._week;
          return wa(this.year(), a.dow, a.doy)
      }
  
      function Cc(a, b, c, d, e) {
          var f;
          return null == a ? va(this, d, e).year : (f = wa(a, d, e), b > f && (b = f), Dc.call(this, a, b, c, d, e))
      }
  
      function Dc(a, b, c, d, e) {
          var f = ua(a, b, c, d, e),
              g = sa(f.year, 0, f.dayOfYear);
          return this.year(g.getUTCFullYear()), this.month(g.getUTCMonth()), this.date(g.getUTCDate()), this
      }
      // MOMENTS
      function Ec(a) {
          return null == a ? Math.ceil((this.month() + 1) / 3) : this.month(3 * (a - 1) + this.month() % 3)
      }
      // HELPERS
      // MOMENTS
      function Fc(a) {
          var b = Math.round((this.clone().startOf("day") - this.clone().startOf("year")) / 864e5) + 1;
          return null == a ? b : this.add(a - b, "d")
      }
  
      function Gc(a, b) {
          b[ce] = t(1e3 * ("0." + a))
      }
      // MOMENTS
      function Hc() {
          return this._isUTC ? "UTC" : ""
      }
  
      function Ic() {
          return this._isUTC ? "Coordinated Universal Time" : ""
      }
  
      function Jc(a) {
          return rb(1e3 * a)
      }
  
      function Kc() {
          return rb.apply(null, arguments).parseZone()
      }
  
      function Lc(a) {
          return a
      }
  
      function Mc(a, b, c, d) {
          var e = ab(),
              f = j().set(d, b);
          return e[c](f, a)
      }
  
      function Nc(a, b, c) {
          if ("number" == typeof a && (b = a, a = void 0), a = a || "", null != b) return Mc(a, b, c, "month");
          var d, e = [];
          for (d = 0; 12 > d; d++) e[d] = Mc(a, d, c, "month");
          return e
      }
      // ()
      // (5)
      // (fmt, 5)
      // (fmt)
      // (true)
      // (true, 5)
      // (true, fmt, 5)
      // (true, fmt)
      function Oc(a, b, c, d) {
          "boolean" == typeof a ? ("number" == typeof b && (c = b, b = void 0), b = b || "") : (b = a, c = b, a = !1, "number" == typeof b && (c = b, b = void 0), b = b || "");
          var e = ab(),
              f = a ? e._week.dow : 0;
          if (null != c) return Mc(b, (c + f) % 7, d, "day");
          var g, h = [];
          for (g = 0; 7 > g; g++) h[g] = Mc(b, (g + f) % 7, d, "day");
          return h
      }
  
      function Pc(a, b) {
          return Nc(a, b, "months")
      }
  
      function Qc(a, b) {
          return Nc(a, b, "monthsShort")
      }
  
      function Rc(a, b, c) {
          return Oc(a, b, c, "weekdays")
      }
  
      function Sc(a, b, c) {
          return Oc(a, b, c, "weekdaysShort")
      }
  
      function Tc(a, b, c) {
          return Oc(a, b, c, "weekdaysMin")
      }
  
      function Uc() {
          var a = this._data;
          return this._milliseconds = Ue(this._milliseconds), this._days = Ue(this._days), this._months = Ue(this._months), a.milliseconds = Ue(a.milliseconds), a.seconds = Ue(a.seconds), a.minutes = Ue(a.minutes), a.hours = Ue(a.hours), a.months = Ue(a.months), a.years = Ue(a.years), this
      }
  
      function Vc(a, b, c, d) {
          var e = Mb(b, c);
          return a._milliseconds += d * e._milliseconds, a._days += d * e._days, a._months += d * e._months, a._bubble()
      }
      // supports only 2.0-style add(1, 's') or add(duration)
      function Wc(a, b) {
          return Vc(this, a, b, 1)
      }
      // supports only 2.0-style subtract(1, 's') or subtract(duration)
      function Xc(a, b) {
          return Vc(this, a, b, -1)
      }
  
      function Yc(a) {
          return 0 > a ? Math.floor(a) : Math.ceil(a)
      }
  
      function Zc() {
          var a, b, c, d, e, f = this._milliseconds,
              g = this._days,
              h = this._months,
              i = this._data;
          // if we have a mix of positive and negative values, bubble down first
          // check: https://github.com/moment/moment/issues/2166
          // The following code bubbles up values, see the tests for
          // examples of what that means.
          // convert days to months
          // 12 months -> 1 year
          return f >= 0 && g >= 0 && h >= 0 || 0 >= f && 0 >= g && 0 >= h || (f += 864e5 * Yc(_c(h) + g), g = 0, h = 0), i.milliseconds = f % 1e3, a = s(f / 1e3), i.seconds = a % 60, b = s(a / 60), i.minutes = b % 60, c = s(b / 60), i.hours = c % 24, g += s(c / 24), e = s($c(g)), h += e, g -= Yc(_c(e)), d = s(h / 12), h %= 12, i.days = g, i.months = h, i.years = d, this
      }
  
      function $c(a) {
          // 400 years have 146097 days (taking into account leap year rules)
          // 400 years have 12 months === 4800
          return 4800 * a / 146097
      }
  
      function _c(a) {
          // the reverse of daysToMonths
          return 146097 * a / 4800
      }
  
      function ad(a) {
          var b, c, d = this._milliseconds;
          if (a = J(a), "month" === a || "year" === a) return b = this._days + d / 864e5, c = this._months + $c(b), "month" === a ? c : c / 12;
          switch (b = this._days + Math.round(_c(this._months)), a) {
              case "week":
                  return b / 7 + d / 6048e5;
              case "day":
                  return b + d / 864e5;
              case "hour":
                  return 24 * b + d / 36e5;
              case "minute":
                  return 1440 * b + d / 6e4;
              case "second":
                  return 86400 * b + d / 1e3;
                  // Math.floor prevents floating point math errors here
              case "millisecond":
                  return Math.floor(864e5 * b) + d;
              default:
                  throw new Error("Unknown unit " + a)
          }
      }
      // TODO: Use this.as('ms')?
      function bd() {
          return this._milliseconds + 864e5 * this._days + this._months % 12 * 2592e6 + 31536e6 * t(this._months / 12)
      }
  
      function cd(a) {
          return function() {
              return this.as(a)
          }
      }
  
      function dd(a) {
          return a = J(a), this[a + "s"]()
      }
  
      function ed(a) {
          return function() {
              return this._data[a]
          }
      }
  
      function fd() {
          return s(this.days() / 7)
      }
      // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
      function gd(a, b, c, d, e) {
          return e.relativeTime(b || 1, !!c, a, d)
      }
  
      function hd(a, b, c) {
          var d = Mb(a).abs(),
              e = jf(d.as("s")),
              f = jf(d.as("m")),
              g = jf(d.as("h")),
              h = jf(d.as("d")),
              i = jf(d.as("M")),
              j = jf(d.as("y")),
              k = e < kf.s && ["s", e] || 1 >= f && ["m"] || f < kf.m && ["mm", f] || 1 >= g && ["h"] || g < kf.h && ["hh", g] || 1 >= h && ["d"] || h < kf.d && ["dd", h] || 1 >= i && ["M"] || i < kf.M && ["MM", i] || 1 >= j && ["y"] || ["yy", j];
          return k[2] = b, k[3] = +a > 0, k[4] = c, gd.apply(null, k)
      }
      // This function allows you to set the rounding function for relative time strings
      function id(a) {
          return void 0 === a ? jf : "function" == typeof a ? (jf = a, !0) : !1
      }
      // This function allows you to set a threshold for relative time strings
      function jd(a, b) {
          return void 0 === kf[a] ? !1 : void 0 === b ? kf[a] : (kf[a] = b, !0)
      }
  
      function kd(a) {
          var b = this.localeData(),
              c = hd(this, !a, b);
          return a && (c = b.pastFuture(+this, c)), b.postformat(c)
      }
  
      function ld() {
          // for ISO strings we do not use the normal bubbling rules:
          //  * milliseconds bubble up until they become hours
          //  * days do not bubble at all
          //  * months bubble up until they become years
          // This is because there is no context-free conversion between hours and days
          // (think of clock changes)
          // and also not between days and months (28-31 days per month)
          var a, b, c, d = lf(this._milliseconds) / 1e3,
              e = lf(this._days),
              f = lf(this._months);
          a = s(d / 60), b = s(a / 60), d %= 60, a %= 60, c = s(f / 12), f %= 12;
          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
          var g = c,
              h = f,
              i = e,
              j = b,
              k = a,
              l = d,
              m = this.asSeconds();
          return m ? (0 > m ? "-" : "") + "P" + (g ? g + "Y" : "") + (h ? h + "M" : "") + (i ? i + "D" : "") + (j || k || l ? "T" : "") + (j ? j + "H" : "") + (k ? k + "M" : "") + (l ? l + "S" : "") : "P0D"
      }
      var md, nd;
      nd = Array.prototype.some ? Array.prototype.some : function(a) {
          for (var b = Object(this), c = b.length >>> 0, d = 0; c > d; d++)
              if (d in b && a.call(this, b[d], d, b)) return !0;
          return !1
      };
      // Plugins that add properties should also add the key here (null value),
      // so we can properly clone ourselves.
      var od = a.momentProperties = [],
          pd = !1,
          qd = {};
      a.suppressDeprecationWarnings = !1, a.deprecationHandler = null;
      var rd;
      rd = Object.keys ? Object.keys : function(a) {
          var b, c = [];
          for (b in a) h(a, b) && c.push(b);
          return c
      };
      var sd, td = {
              sameDay: "[Today at] LT",
              nextDay: "[Tomorrow at] LT",
              nextWeek: "dddd [at] LT",
              lastDay: "[Yesterday at] LT",
              lastWeek: "[Last] dddd [at] LT",
              sameElse: "L"
          },
          ud = {
              LTS: "h:mm:ss A",
              LT: "h:mm A",
              L: "MM/DD/YYYY",
              LL: "MMMM D, YYYY",
              LLL: "MMMM D, YYYY h:mm A",
              LLLL: "dddd, MMMM D, YYYY h:mm A"
          },
          vd = "Invalid date",
          wd = "%d",
          xd = /\d{1,2}/,
          yd = {
              future: "in %s",
              past: "%s ago",
              s: "a few seconds",
              m: "a minute",
              mm: "%d minutes",
              h: "an hour",
              hh: "%d hours",
              d: "a day",
              dd: "%d days",
              M: "a month",
              MM: "%d months",
              y: "a year",
              yy: "%d years"
          },
          zd = {},
          Ad = {},
          Bd = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
          Cd = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
          Dd = {},
          Ed = {},
          Fd = /\d/,
          Gd = /\d\d/,
          Hd = /\d{3}/,
          Id = /\d{4}/,
          Jd = /[+-]?\d{6}/,
          Kd = /\d\d?/,
          Ld = /\d\d\d\d?/,
          Md = /\d\d\d\d\d\d?/,
          Nd = /\d{1,3}/,
          Od = /\d{1,4}/,
          Pd = /[+-]?\d{1,6}/,
          Qd = /\d+/,
          Rd = /[+-]?\d+/,
          Sd = /Z|[+-]\d\d:?\d\d/gi,
          Td = /Z|[+-]\d\d(?::?\d\d)?/gi,
          Ud = /[+-]?\d+(\.\d{1,3})?/,
          Vd = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,
          Wd = {},
          Xd = {},
          Yd = 0,
          Zd = 1,
          $d = 2,
          _d = 3,
          ae = 4,
          be = 5,
          ce = 6,
          de = 7,
          ee = 8;
      sd = Array.prototype.indexOf ? Array.prototype.indexOf : function(a) {
          // I know
          var b;
          for (b = 0; b < this.length; ++b)
              if (this[b] === a) return b;
          return -1
      }, T("M", ["MM", 2], "Mo", function() {
          return this.month() + 1
      }), T("MMM", 0, 0, function(a) {
          return this.localeData().monthsShort(this, a)
      }), T("MMMM", 0, 0, function(a) {
          return this.localeData().months(this, a)
      }), I("month", "M"), L("month", 8), Y("M", Kd), Y("MM", Kd, Gd), Y("MMM", function(a, b) {
          return b.monthsShortRegex(a)
      }), Y("MMMM", function(a, b) {
          return b.monthsRegex(a)
      }), aa(["M", "MM"], function(a, b) {
          b[Zd] = t(a) - 1
      }), aa(["MMM", "MMMM"], function(a, b, c, d) {
          var e = c._locale.monthsParse(a, d, c._strict);
          null != e ? b[Zd] = e : l(c).invalidMonth = a
      });
      // LOCALES
      var fe = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/,
          ge = "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
          he = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
          ie = Vd,
          je = Vd;
      // FORMATTING
      T("Y", 0, 0, function() {
              var a = this.year();
              return 9999 >= a ? "" + a : "+" + a
          }), T(0, ["YY", 2], 0, function() {
              return this.year() % 100
          }), T(0, ["YYYY", 4], 0, "year"), T(0, ["YYYYY", 5], 0, "year"), T(0, ["YYYYYY", 6, !0], 0, "year"),
          // ALIASES
          I("year", "y"),
          // PRIORITIES
          L("year", 1),
          // PARSING
          Y("Y", Rd), Y("YY", Kd, Gd), Y("YYYY", Od, Id), Y("YYYYY", Pd, Jd), Y("YYYYYY", Pd, Jd), aa(["YYYYY", "YYYYYY"], Yd), aa("YYYY", function(b, c) {
              c[Yd] = 2 === b.length ? a.parseTwoDigitYear(b) : t(b)
          }), aa("YY", function(b, c) {
              c[Yd] = a.parseTwoDigitYear(b)
          }), aa("Y", function(a, b) {
              b[Yd] = parseInt(a, 10)
          }),
          // HOOKS
          a.parseTwoDigitYear = function(a) {
              return t(a) + (t(a) > 68 ? 1900 : 2e3)
          };
      // MOMENTS
      var ke = N("FullYear", !0);
      // FORMATTING
      T("w", ["ww", 2], "wo", "week"), T("W", ["WW", 2], "Wo", "isoWeek"),
          // ALIASES
          I("week", "w"), I("isoWeek", "W"),
          // PRIORITIES
          L("week", 5), L("isoWeek", 5),
          // PARSING
          Y("w", Kd), Y("ww", Kd, Gd), Y("W", Kd), Y("WW", Kd, Gd), ba(["w", "ww", "W", "WW"], function(a, b, c, d) {
              b[d.substr(0, 1)] = t(a)
          });
      var le = {
          dow: 0, // Sunday is the first day of the week.
          doy: 6
      };
      // FORMATTING
      T("d", 0, "do", "day"), T("dd", 0, 0, function(a) {
              return this.localeData().weekdaysMin(this, a)
          }), T("ddd", 0, 0, function(a) {
              return this.localeData().weekdaysShort(this, a)
          }), T("dddd", 0, 0, function(a) {
              return this.localeData().weekdays(this, a)
          }), T("e", 0, 0, "weekday"), T("E", 0, 0, "isoWeekday"),
          // ALIASES
          I("day", "d"), I("weekday", "e"), I("isoWeekday", "E"),
          // PRIORITY
          L("day", 11), L("weekday", 11), L("isoWeekday", 11),
          // PARSING
          Y("d", Kd), Y("e", Kd), Y("E", Kd), Y("dd", function(a, b) {
              return b.weekdaysMinRegex(a)
          }), Y("ddd", function(a, b) {
              return b.weekdaysShortRegex(a)
          }), Y("dddd", function(a, b) {
              return b.weekdaysRegex(a)
          }), ba(["dd", "ddd", "dddd"], function(a, b, c, d) {
              var e = c._locale.weekdaysParse(a, d, c._strict);
              // if we didn't get a weekday name, mark the date as invalid
              null != e ? b.d = e : l(c).invalidWeekday = a
          }), ba(["d", "e", "E"], function(a, b, c, d) {
              b[d] = t(a)
          });
      // LOCALES
      var me = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
          ne = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
          oe = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
          pe = Vd,
          qe = Vd,
          re = Vd;
      T("H", ["HH", 2], 0, "hour"), T("h", ["hh", 2], 0, Qa), T("k", ["kk", 2], 0, Ra), T("hmm", 0, 0, function() {
              return "" + Qa.apply(this) + S(this.minutes(), 2)
          }), T("hmmss", 0, 0, function() {
              return "" + Qa.apply(this) + S(this.minutes(), 2) + S(this.seconds(), 2)
          }), T("Hmm", 0, 0, function() {
              return "" + this.hours() + S(this.minutes(), 2)
          }), T("Hmmss", 0, 0, function() {
              return "" + this.hours() + S(this.minutes(), 2) + S(this.seconds(), 2)
          }), Sa("a", !0), Sa("A", !1),
          // ALIASES
          I("hour", "h"),
          // PRIORITY
          L("hour", 13), Y("a", Ta), Y("A", Ta), Y("H", Kd), Y("h", Kd), Y("HH", Kd, Gd), Y("hh", Kd, Gd), Y("hmm", Ld), Y("hmmss", Md), Y("Hmm", Ld), Y("Hmmss", Md), aa(["H", "HH"], _d), aa(["a", "A"], function(a, b, c) {
              c._isPm = c._locale.isPM(a), c._meridiem = a
          }), aa(["h", "hh"], function(a, b, c) {
              b[_d] = t(a), l(c).bigHour = !0
          }), aa("hmm", function(a, b, c) {
              var d = a.length - 2;
              b[_d] = t(a.substr(0, d)), b[ae] = t(a.substr(d)), l(c).bigHour = !0
          }), aa("hmmss", function(a, b, c) {
              var d = a.length - 4,
                  e = a.length - 2;
              b[_d] = t(a.substr(0, d)), b[ae] = t(a.substr(d, 2)), b[be] = t(a.substr(e)), l(c).bigHour = !0
          }), aa("Hmm", function(a, b, c) {
              var d = a.length - 2;
              b[_d] = t(a.substr(0, d)), b[ae] = t(a.substr(d))
          }), aa("Hmmss", function(a, b, c) {
              var d = a.length - 4,
                  e = a.length - 2;
              b[_d] = t(a.substr(0, d)), b[ae] = t(a.substr(d, 2)), b[be] = t(a.substr(e))
          });
      var se, te = /[ap]\.?m?\.?/i,
          ue = N("Hours", !0),
          ve = {
              calendar: td,
              longDateFormat: ud,
              invalidDate: vd,
              ordinal: wd,
              ordinalParse: xd,
              relativeTime: yd,
              months: ge,
              monthsShort: he,
              week: le,
              weekdays: me,
              weekdaysMin: oe,
              weekdaysShort: ne,
              meridiemParse: te
          },
          we = {},
          xe = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/,
          ye = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/,
          ze = /Z|[+-]\d\d(?::?\d\d)?/,
          Ae = [
              ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
              ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
              ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
              ["GGGG-[W]WW", /\d{4}-W\d\d/, !1],
              ["YYYY-DDD", /\d{4}-\d{3}/],
              ["YYYY-MM", /\d{4}-\d\d/, !1],
              ["YYYYYYMMDD", /[+-]\d{10}/],
              ["YYYYMMDD", /\d{8}/],
              // YYYYMM is NOT allowed by the standard
              ["GGGG[W]WWE", /\d{4}W\d{3}/],
              ["GGGG[W]WW", /\d{4}W\d{2}/, !1],
              ["YYYYDDD", /\d{7}/]
          ],
          Be = [
              ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
              ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
              ["HH:mm:ss", /\d\d:\d\d:\d\d/],
              ["HH:mm", /\d\d:\d\d/],
              ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
              ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
              ["HHmmss", /\d\d\d\d\d\d/],
              ["HHmm", /\d\d\d\d/],
              ["HH", /\d\d/]
          ],
          Ce = /^\/?Date\((\-?\d+)/i;
      a.createFromInputFallback = w("moment construction falls back to js Date. This is discouraged and will be removed in upcoming major release. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.", function(a) {
              a._d = new Date(a._i + (a._useUTC ? " UTC" : ""))
          }),
          // constant that refers to the ISO standard
          a.ISO_8601 = function() {};
      var De = w("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/", function() {
              var a = rb.apply(null, arguments);
              return this.isValid() && a.isValid() ? this > a ? this : a : n()
          }),
          Ee = w("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/", function() {
              var a = rb.apply(null, arguments);
              return this.isValid() && a.isValid() ? a > this ? this : a : n()
          }),
          Fe = function() {
              return Date.now ? Date.now() : +new Date
          };
      xb("Z", ":"), xb("ZZ", ""),
          // PARSING
          Y("Z", Td), Y("ZZ", Td), aa(["Z", "ZZ"], function(a, b, c) {
              c._useUTC = !0, c._tzm = yb(Td, a)
          });
      // HELPERS
      // timezone chunker
      // '+10:00' > ['10',  '00']
      // '-1530'  > ['-15', '30']
      var Ge = /([\+\-]|\d\d)/gi;
      // HOOKS
      // This function will be called whenever a moment is mutated.
      // It is intended to keep the offset in sync with the timezone.
      a.updateOffset = function() {};
      // ASP.NET json date format regex
      var He = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/,
          Ie = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
      Mb.fn = vb.prototype;
      var Je = Rb(1, "add"),
          Ke = Rb(-1, "subtract");
      a.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ", a.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
      var Le = w("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.", function(a) {
          return void 0 === a ? this.localeData() : this.locale(a)
      });
      // FORMATTING
      T(0, ["gg", 2], 0, function() {
              return this.weekYear() % 100
          }), T(0, ["GG", 2], 0, function() {
              return this.isoWeekYear() % 100
          }), xc("gggg", "weekYear"), xc("ggggg", "weekYear"), xc("GGGG", "isoWeekYear"), xc("GGGGG", "isoWeekYear"),
          // ALIASES
          I("weekYear", "gg"), I("isoWeekYear", "GG"),
          // PRIORITY
          L("weekYear", 1), L("isoWeekYear", 1),
          // PARSING
          Y("G", Rd), Y("g", Rd), Y("GG", Kd, Gd), Y("gg", Kd, Gd), Y("GGGG", Od, Id), Y("gggg", Od, Id), Y("GGGGG", Pd, Jd), Y("ggggg", Pd, Jd), ba(["gggg", "ggggg", "GGGG", "GGGGG"], function(a, b, c, d) {
              b[d.substr(0, 2)] = t(a)
          }), ba(["gg", "GG"], function(b, c, d, e) {
              c[e] = a.parseTwoDigitYear(b)
          }),
          // FORMATTING
          T("Q", 0, "Qo", "quarter"),
          // ALIASES
          I("quarter", "Q"),
          // PRIORITY
          L("quarter", 7),
          // PARSING
          Y("Q", Fd), aa("Q", function(a, b) {
              b[Zd] = 3 * (t(a) - 1)
          }),
          // FORMATTING
          T("D", ["DD", 2], "Do", "date"),
          // ALIASES
          I("date", "D"),
          // PRIOROITY
          L("date", 9),
          // PARSING
          Y("D", Kd), Y("DD", Kd, Gd), Y("Do", function(a, b) {
              return a ? b._ordinalParse : b._ordinalParseLenient
          }), aa(["D", "DD"], $d), aa("Do", function(a, b) {
              b[$d] = t(a.match(Kd)[0], 10)
          });
      // MOMENTS
      var Me = N("Date", !0);
      // FORMATTING
      T("DDD", ["DDDD", 3], "DDDo", "dayOfYear"),
          // ALIASES
          I("dayOfYear", "DDD"),
          // PRIORITY
          L("dayOfYear", 4),
          // PARSING
          Y("DDD", Nd), Y("DDDD", Hd), aa(["DDD", "DDDD"], function(a, b, c) {
              c._dayOfYear = t(a)
          }),
          // FORMATTING
          T("m", ["mm", 2], 0, "minute"),
          // ALIASES
          I("minute", "m"),
          // PRIORITY
          L("minute", 14),
          // PARSING
          Y("m", Kd), Y("mm", Kd, Gd), aa(["m", "mm"], ae);
      // MOMENTS
      var Ne = N("Minutes", !1);
      // FORMATTING
      T("s", ["ss", 2], 0, "second"),
          // ALIASES
          I("second", "s"),
          // PRIORITY
          L("second", 15),
          // PARSING
          Y("s", Kd), Y("ss", Kd, Gd), aa(["s", "ss"], be);
      // MOMENTS
      var Oe = N("Seconds", !1);
      // FORMATTING
      T("S", 0, 0, function() {
              return ~~(this.millisecond() / 100)
          }), T(0, ["SS", 2], 0, function() {
              return ~~(this.millisecond() / 10)
          }), T(0, ["SSS", 3], 0, "millisecond"), T(0, ["SSSS", 4], 0, function() {
              return 10 * this.millisecond()
          }), T(0, ["SSSSS", 5], 0, function() {
              return 100 * this.millisecond()
          }), T(0, ["SSSSSS", 6], 0, function() {
              return 1e3 * this.millisecond()
          }), T(0, ["SSSSSSS", 7], 0, function() {
              return 1e4 * this.millisecond()
          }), T(0, ["SSSSSSSS", 8], 0, function() {
              return 1e5 * this.millisecond()
          }), T(0, ["SSSSSSSSS", 9], 0, function() {
              return 1e6 * this.millisecond()
          }),
          // ALIASES
          I("millisecond", "ms"),
          // PRIORITY
          L("millisecond", 16),
          // PARSING
          Y("S", Nd, Fd), Y("SS", Nd, Gd), Y("SSS", Nd, Hd);
      var Pe;
      for (Pe = "SSSS"; Pe.length <= 9; Pe += "S") Y(Pe, Qd);
      for (Pe = "S"; Pe.length <= 9; Pe += "S") aa(Pe, Gc);
      // MOMENTS
      var Qe = N("Milliseconds", !1);
      // FORMATTING
      T("z", 0, 0, "zoneAbbr"), T("zz", 0, 0, "zoneName");
      var Re = q.prototype;
      Re.add = Je, Re.calendar = Ub, Re.clone = Vb, Re.diff = ac, Re.endOf = mc, Re.format = ec, Re.from = fc, Re.fromNow = gc, Re.to = hc, Re.toNow = ic, Re.get = Q, Re.invalidAt = vc, Re.isAfter = Wb, Re.isBefore = Xb, Re.isBetween = Yb, Re.isSame = Zb, Re.isSameOrAfter = $b, Re.isSameOrBefore = _b, Re.isValid = tc, Re.lang = Le, Re.locale = jc, Re.localeData = kc, Re.max = Ee, Re.min = De, Re.parsingFlags = uc, Re.set = R, Re.startOf = lc, Re.subtract = Ke, Re.toArray = qc, Re.toObject = rc, Re.toDate = pc, Re.toISOString = dc, Re.toJSON = sc, Re.toString = cc, Re.unix = oc, Re.valueOf = nc, Re.creationData = wc,
          // Year
          Re.year = ke, Re.isLeapYear = qa,
          // Week Year
          Re.weekYear = yc, Re.isoWeekYear = zc,
          // Quarter
          Re.quarter = Re.quarters = Ec,
          // Month
          Re.month = ja, Re.daysInMonth = ka,
          // Week
          Re.week = Re.weeks = Aa, Re.isoWeek = Re.isoWeeks = Ba, Re.weeksInYear = Bc, Re.isoWeeksInYear = Ac,
          // Day
          Re.date = Me, Re.day = Re.days = Ja, Re.weekday = Ka, Re.isoWeekday = La, Re.dayOfYear = Fc,
          // Hour
          Re.hour = Re.hours = ue,
          // Minute
          Re.minute = Re.minutes = Ne,
          // Second
          Re.second = Re.seconds = Oe,
          // Millisecond
          Re.millisecond = Re.milliseconds = Qe,
          // Offset
          Re.utcOffset = Bb, Re.utc = Db, Re.local = Eb, Re.parseZone = Fb, Re.hasAlignedHourOffset = Gb, Re.isDST = Hb, Re.isLocal = Jb, Re.isUtcOffset = Kb, Re.isUtc = Lb, Re.isUTC = Lb,
          // Timezone
          Re.zoneAbbr = Hc, Re.zoneName = Ic,
          // Deprecations
          Re.dates = w("dates accessor is deprecated. Use date instead.", Me), Re.months = w("months accessor is deprecated. Use month instead", ja), Re.years = w("years accessor is deprecated. Use year instead", ke), Re.zone = w("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/", Cb), Re.isDSTShifted = w("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information", Ib);
      var Se = Re,
          Te = B.prototype;
      Te.calendar = C, Te.longDateFormat = D, Te.invalidDate = E, Te.ordinal = F, Te.preparse = Lc, Te.postformat = Lc, Te.relativeTime = G, Te.pastFuture = H, Te.set = z,
          // Month
          Te.months = ea, Te.monthsShort = fa, Te.monthsParse = ha, Te.monthsRegex = ma, Te.monthsShortRegex = la,
          // Week
          Te.week = xa, Te.firstDayOfYear = za, Te.firstDayOfWeek = ya,
          // Day of Week
          Te.weekdays = Ea, Te.weekdaysMin = Ga, Te.weekdaysShort = Fa, Te.weekdaysParse = Ia, Te.weekdaysRegex = Ma, Te.weekdaysShortRegex = Na, Te.weekdaysMinRegex = Oa,
          // Hours
          Te.isPM = Ua, Te.meridiem = Va, Za("en", {
              ordinalParse: /\d{1,2}(th|st|nd|rd)/,
              ordinal: function(a) {
                  var b = a % 10,
                      c = 1 === t(a % 100 / 10) ? "th" : 1 === b ? "st" : 2 === b ? "nd" : 3 === b ? "rd" : "th";
                  return a + c
              }
          }),
          // Side effect imports
          a.lang = w("moment.lang is deprecated. Use moment.locale instead.", Za), a.langData = w("moment.langData is deprecated. Use moment.localeData instead.", ab);
      var Ue = Math.abs,
          Ve = cd("ms"),
          We = cd("s"),
          Xe = cd("m"),
          Ye = cd("h"),
          Ze = cd("d"),
          $e = cd("w"),
          _e = cd("M"),
          af = cd("y"),
          bf = ed("milliseconds"),
          cf = ed("seconds"),
          df = ed("minutes"),
          ef = ed("hours"),
          ff = ed("days"),
          gf = ed("months"),
          hf = ed("years"),
          jf = Math.round,
          kf = {
              s: 45, // seconds to minute
              m: 45, // minutes to hour
              h: 22, // hours to day
              d: 26, // days to month
              M: 11
          },
          lf = Math.abs,
          mf = vb.prototype;
      mf.abs = Uc, mf.add = Wc, mf.subtract = Xc, mf.as = ad, mf.asMilliseconds = Ve, mf.asSeconds = We, mf.asMinutes = Xe, mf.asHours = Ye, mf.asDays = Ze, mf.asWeeks = $e, mf.asMonths = _e, mf.asYears = af, mf.valueOf = bd, mf._bubble = Zc, mf.get = dd, mf.milliseconds = bf, mf.seconds = cf, mf.minutes = df, mf.hours = ef, mf.days = ff, mf.weeks = fd, mf.months = gf, mf.years = hf, mf.humanize = kd, mf.toISOString = ld, mf.toString = ld, mf.toJSON = ld, mf.locale = jc, mf.localeData = kc,
          // Deprecations
          mf.toIsoString = w("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", ld), mf.lang = Le,
          // Side effect imports
          // FORMATTING
          T("X", 0, 0, "unix"), T("x", 0, 0, "valueOf"),
          // PARSING
          Y("x", Rd), Y("X", Ud), aa("X", function(a, b, c) {
              c._d = new Date(1e3 * parseFloat(a, 10))
          }), aa("x", function(a, b, c) {
              c._d = new Date(t(a))
          }),
          // Side effect imports
          a.version = "2.14.1", b(rb), a.fn = Se, a.min = tb, a.max = ub, a.now = Fe, a.utc = j, a.unix = Jc, a.months = Pc, a.isDate = f, a.locale = Za, a.invalid = n, a.duration = Mb, a.isMoment = r, a.weekdays = Rc, a.parseZone = Kc, a.localeData = ab, a.isDuration = wb, a.monthsShort = Qc, a.weekdaysMin = Tc, a.defineLocale = $a, a.updateLocale = _a, a.locales = bb, a.weekdaysShort = Sc, a.normalizeUnits = J, a.relativeTimeRounding = id, a.relativeTimeThreshold = jd, a.calendarFormat = Tb, a.prototype = Se;
      var nf = a;
      return nf
  });
  /*! nouislider - 10.0.0 */
  
  ! function(a) {
      "function" == typeof define && define.amd ? define([], a) : "object" == typeof exports ? module.exports = a() : window.noUiSlider = a()
  }(function() {
      "use strict";
  
      function a(a) {
          return "object" == typeof a && "function" == typeof a.to && "function" == typeof a.from
      }
  
      function b(a) {
          a.parentElement.removeChild(a)
      }
  
      function c(a) {
          a.preventDefault()
      }
  
      function d(a) {
          return a.filter(function(a) {
              return this[a] ? !1 : this[a] = !0
          }, {})
      }
  
      function e(a, b) {
          return Math.round(a / b) * b
      }
  
      function f(a, b) {
          var c = a.getBoundingClientRect(),
              d = a.ownerDocument,
              e = d.documentElement,
              f = o(d);
          return /webkit.*Chrome.*Mobile/i.test(navigator.userAgent) && (f.x = 0), b ? c.top + f.y - e.clientTop : c.left + f.x - e.clientLeft
      }
  
      function g(a) {
          return "number" == typeof a && !isNaN(a) && isFinite(a)
      }
  
      function h(a, b, c) {
          c > 0 && (l(a, b), setTimeout(function() {
              m(a, b)
          }, c))
      }
  
      function i(a) {
          return Math.max(Math.min(a, 100), 0)
      }
  
      function j(a) {
          return Array.isArray(a) ? a : [a]
      }
  
      function k(a) {
          a = String(a);
          var b = a.split(".");
          return b.length > 1 ? b[1].length : 0
      }
  
      function l(a, b) {
          a.classList ? a.classList.add(b) : a.className += " " + b
      }
  
      function m(a, b) {
          a.classList ? a.classList.remove(b) : a.className = a.className.replace(new RegExp("(^|\\b)" + b.split(" ").join("|") + "(\\b|$)", "gi"), " ")
      }
  
      function n(a, b) {
          return a.classList ? a.classList.contains(b) : new RegExp("\\b" + b + "\\b").test(a.className)
      }
  
      function o(a) {
          var b = void 0 !== window.pageXOffset,
              c = "CSS1Compat" === (a.compatMode || ""),
              d = b ? window.pageXOffset : c ? a.documentElement.scrollLeft : a.body.scrollLeft,
              e = b ? window.pageYOffset : c ? a.documentElement.scrollTop : a.body.scrollTop;
          return {
              x: d,
              y: e
          }
      }
  
      function p() {
          return window.navigator.pointerEnabled ? {
              start: "pointerdown",
              move: "pointermove",
              end: "pointerup"
          } : window.navigator.msPointerEnabled ? {
              start: "MSPointerDown",
              move: "MSPointerMove",
              end: "MSPointerUp"
          } : {
              start: "mousedown touchstart",
              move: "mousemove touchmove",
              end: "mouseup touchend"
          }
      }
  
      function q() {
          var a = !1;
          try {
              var b = Object.defineProperty({}, "passive", {
                  get: function() {
                      a = !0
                  }
              });
              window.addEventListener("test", null, b)
          } catch (c) {}
          return a
      }
  
      function r() {
          return window.CSS && CSS.supports && CSS.supports("touch-action", "none")
      }
  
      function s(a, b) {
          return 100 / (b - a)
      }
  
      function t(a, b) {
          return 100 * b / (a[1] - a[0])
      }
  
      function u(a, b) {
          return t(a, a[0] < 0 ? b + Math.abs(a[0]) : b - a[0])
      }
  
      function v(a, b) {
          return b * (a[1] - a[0]) / 100 + a[0]
      }
  
      function w(a, b) {
          for (var c = 1; a >= b[c];) c += 1;
          return c
      }
  
      function x(a, b, c) {
          if (c >= a.slice(-1)[0]) return 100;
          var d, e, f, g, h = w(c, a);
          return d = a[h - 1], e = a[h], f = b[h - 1], g = b[h], f + u([d, e], c) / s(f, g)
      }
  
      function y(a, b, c) {
          if (c >= 100) return a.slice(-1)[0];
          var d, e, f, g, h = w(c, b);
          return d = a[h - 1], e = a[h], f = b[h - 1], g = b[h], v([d, e], (c - f) * s(f, g))
      }
  
      function z(a, b, c, d) {
          if (100 === d) return d;
          var f, g, h = w(d, a);
          return c ? (f = a[h - 1], g = a[h], d - f > (g - f) / 2 ? g : f) : b[h - 1] ? a[h - 1] + e(d - a[h - 1], b[h - 1]) : d
      }
  
      function A(a, b, c) {
          var d;
          if ("number" == typeof b && (b = [b]), "[object Array]" !== Object.prototype.toString.call(b)) throw new Error("noUiSlider (" + $ + "): 'range' contains invalid value.");
          if (d = "min" === a ? 0 : "max" === a ? 100 : parseFloat(a), !g(d) || !g(b[0])) throw new Error("noUiSlider (" + $ + "): 'range' value isn't numeric.");
          c.xPct.push(d), c.xVal.push(b[0]), d ? c.xSteps.push(isNaN(b[1]) ? !1 : b[1]) : isNaN(b[1]) || (c.xSteps[0] = b[1]), c.xHighestCompleteStep.push(0)
      }
  
      function B(a, b, c) {
          if (!b) return !0;
          c.xSteps[a] = t([c.xVal[a], c.xVal[a + 1]], b) / s(c.xPct[a], c.xPct[a + 1]);
          var d = (c.xVal[a + 1] - c.xVal[a]) / c.xNumSteps[a],
              e = Math.ceil(Number(d.toFixed(3)) - 1),
              f = c.xVal[a] + c.xNumSteps[a] * e;
          c.xHighestCompleteStep[a] = f
      }
  
      function C(a, b, c) {
          this.xPct = [], this.xVal = [], this.xSteps = [c || !1], this.xNumSteps = [!1], this.xHighestCompleteStep = [], this.snap = b;
          var d, e = [];
          for (d in a) a.hasOwnProperty(d) && e.push([a[d], d]);
          for (e.sort(e.length && "object" == typeof e[0][0] ? function(a, b) {
                  return a[0][0] - b[0][0]
              } : function(a, b) {
                  return a[0] - b[0]
              }), d = 0; d < e.length; d++) A(e[d][1], e[d][0], this);
          for (this.xNumSteps = this.xSteps.slice(0), d = 0; d < this.xNumSteps.length; d++) B(d, this.xNumSteps[d], this)
      }
  
      function D(b) {
          if (a(b)) return !0;
          throw new Error("noUiSlider (" + $ + "): 'format' requires 'to' and 'from' methods.")
      }
  
      function E(a, b) {
          if (!g(b)) throw new Error("noUiSlider (" + $ + "): 'step' is not numeric.");
          a.singleStep = b
      }
  
      function F(a, b) {
          if ("object" != typeof b || Array.isArray(b)) throw new Error("noUiSlider (" + $ + "): 'range' is not an object.");
          if (void 0 === b.min || void 0 === b.max) throw new Error("noUiSlider (" + $ + "): Missing 'min' or 'max' in 'range'.");
          if (b.min === b.max) throw new Error("noUiSlider (" + $ + "): 'range' 'min' and 'max' cannot be equal.");
          a.spectrum = new C(b, a.snap, a.singleStep)
      }
  
      function G(a, b) {
          if (b = j(b), !Array.isArray(b) || !b.length) throw new Error("noUiSlider (" + $ + "): 'start' option is incorrect.");
          a.handles = b.length, a.start = b
      }
  
      function H(a, b) {
          if (a.snap = b, "boolean" != typeof b) throw new Error("noUiSlider (" + $ + "): 'snap' option must be a boolean.")
      }
  
      function I(a, b) {
          if (a.animate = b, "boolean" != typeof b) throw new Error("noUiSlider (" + $ + "): 'animate' option must be a boolean.")
      }
  
      function J(a, b) {
          if (a.animationDuration = b, "number" != typeof b) throw new Error("noUiSlider (" + $ + "): 'animationDuration' option must be a number.")
      }
  
      function K(a, b) {
          var c, d = [!1];
          if ("lower" === b ? b = [!0, !1] : "upper" === b && (b = [!1, !0]), b === !0 || b === !1) {
              for (c = 1; c < a.handles; c++) d.push(b);
              d.push(!1)
          } else {
              if (!Array.isArray(b) || !b.length || b.length !== a.handles + 1) throw new Error("noUiSlider (" + $ + "): 'connect' option doesn't match handle count.");
              d = b
          }
          a.connect = d
      }
  
      function L(a, b) {
          switch (b) {
              case "horizontal":
                  a.ort = 0;
                  break;
              case "vertical":
                  a.ort = 1;
                  break;
              default:
                  throw new Error("noUiSlider (" + $ + "): 'orientation' option is invalid.")
          }
      }
  
      function M(a, b) {
          if (!g(b)) throw new Error("noUiSlider (" + $ + "): 'margin' option must be numeric.");
          if (0 !== b && (a.margin = a.spectrum.getMargin(b), !a.margin)) throw new Error("noUiSlider (" + $ + "): 'margin' option is only supported on linear sliders.")
      }
  
      function N(a, b) {
          if (!g(b)) throw new Error("noUiSlider (" + $ + "): 'limit' option must be numeric.");
          if (a.limit = a.spectrum.getMargin(b), !a.limit || a.handles < 2) throw new Error("noUiSlider (" + $ + "): 'limit' option is only supported on linear sliders with 2 or more handles.")
      }
  
      function O(a, b) {
          if (!g(b)) throw new Error("noUiSlider (" + $ + "): 'padding' option must be numeric.");
          if (0 !== b) {
              if (a.padding = a.spectrum.getMargin(b), !a.padding) throw new Error("noUiSlider (" + $ + "): 'padding' option is only supported on linear sliders.");
              if (a.padding < 0) throw new Error("noUiSlider (" + $ + "): 'padding' option must be a positive number.");
              if (a.padding >= 50) throw new Error("noUiSlider (" + $ + "): 'padding' option must be less than half the range.")
          }
      }
  
      function P(a, b) {
          switch (b) {
              case "ltr":
                  a.dir = 0;
                  break;
              case "rtl":
                  a.dir = 1;
                  break;
              default:
                  throw new Error("noUiSlider (" + $ + "): 'direction' option was not recognized.")
          }
      }
  
      function Q(a, b) {
          if ("string" != typeof b) throw new Error("noUiSlider (" + $ + "): 'behaviour' must be a string containing options.");
          var c = b.indexOf("tap") >= 0,
              d = b.indexOf("drag") >= 0,
              e = b.indexOf("fixed") >= 0,
              f = b.indexOf("snap") >= 0,
              g = b.indexOf("hover") >= 0;
          if (e) {
              if (2 !== a.handles) throw new Error("noUiSlider (" + $ + "): 'fixed' behaviour must be used with 2 handles");
              M(a, a.start[1] - a.start[0])
          }
          a.events = {
              tap: c || f,
              drag: d,
              fixed: e,
              snap: f,
              hover: g
          }
      }
  
      function R(a, b) {
          if (b !== !1)
              if (b === !0) {
                  a.tooltips = [];
                  for (var c = 0; c < a.handles; c++) a.tooltips.push(!0)
              } else {
                  if (a.tooltips = j(b), a.tooltips.length !== a.handles) throw new Error("noUiSlider (" + $ + "): must pass a formatter for all handles.");
                  a.tooltips.forEach(function(a) {
                      if ("boolean" != typeof a && ("object" != typeof a || "function" != typeof a.to)) throw new Error("noUiSlider (" + $ + "): 'tooltips' must be passed a formatter or 'false'.")
                  })
              }
      }
  
      function S(a, b) {
          a.ariaFormat = b, D(b)
      }
  
      function T(a, b) {
          a.format = b, D(b)
      }
  
      function U(a, b) {
          if (void 0 !== b && "string" != typeof b && b !== !1) throw new Error("noUiSlider (" + $ + "): 'cssPrefix' must be a string or `false`.");
          a.cssPrefix = b
      }
  
      function V(a, b) {
          if (void 0 !== b && "object" != typeof b) throw new Error("noUiSlider (" + $ + "): 'cssClasses' must be an object.");
          if ("string" == typeof a.cssPrefix) {
              a.cssClasses = {};
              for (var c in b) b.hasOwnProperty(c) && (a.cssClasses[c] = a.cssPrefix + b[c])
          } else a.cssClasses = b
      }
  
      function W(a, b) {
          if (b !== !0 && b !== !1) throw new Error("noUiSlider (" + $ + "): 'useRequestAnimationFrame' option should be true (default) or false.");
          a.useRequestAnimationFrame = b
      }
  
      function X(a) {
          var b = {
                  margin: 0,
                  limit: 0,
                  padding: 0,
                  animate: !0,
                  animationDuration: 300,
                  ariaFormat: _,
                  format: _
              },
              c = {
                  step: {
                      r: !1,
                      t: E
                  },
                  start: {
                      r: !0,
                      t: G
                  },
                  connect: {
                      r: !0,
                      t: K
                  },
                  direction: {
                      r: !0,
                      t: P
                  },
                  snap: {
                      r: !1,
                      t: H
                  },
                  animate: {
                      r: !1,
                      t: I
                  },
                  animationDuration: {
                      r: !1,
                      t: J
                  },
                  range: {
                      r: !0,
                      t: F
                  },
                  orientation: {
                      r: !1,
                      t: L
                  },
                  margin: {
                      r: !1,
                      t: M
                  },
                  limit: {
                      r: !1,
                      t: N
                  },
                  padding: {
                      r: !1,
                      t: O
                  },
                  behaviour: {
                      r: !0,
                      t: Q
                  },
                  ariaFormat: {
                      r: !1,
                      t: S
                  },
                  format: {
                      r: !1,
                      t: T
                  },
                  tooltips: {
                      r: !1,
                      t: R
                  },
                  cssPrefix: {
                      r: !1,
                      t: U
                  },
                  cssClasses: {
                      r: !1,
                      t: V
                  },
                  useRequestAnimationFrame: {
                      r: !1,
                      t: W
                  }
              },
              d = {
                  connect: !1,
                  direction: "ltr",
                  behaviour: "tap",
                  orientation: "horizontal",
                  cssPrefix: "noUi-",
                  cssClasses: {
                      target: "target",
                      base: "base",
                      origin: "origin",
                      handle: "handle",
                      handleLower: "handle-lower",
                      handleUpper: "handle-upper",
                      horizontal: "horizontal",
                      vertical: "vertical",
                      background: "background",
                      connect: "connect",
                      ltr: "ltr",
                      rtl: "rtl",
                      draggable: "draggable",
                      drag: "state-drag",
                      tap: "state-tap",
                      active: "active",
                      tooltip: "tooltip",
                      pips: "pips",
                      pipsHorizontal: "pips-horizontal",
                      pipsVertical: "pips-vertical",
                      marker: "marker",
                      markerHorizontal: "marker-horizontal",
                      markerVertical: "marker-vertical",
                      markerNormal: "marker-normal",
                      markerLarge: "marker-large",
                      markerSub: "marker-sub",
                      value: "value",
                      valueHorizontal: "value-horizontal",
                      valueVertical: "value-vertical",
                      valueNormal: "value-normal",
                      valueLarge: "value-large",
                      valueSub: "value-sub"
                  },
                  useRequestAnimationFrame: !0
              };
          a.format && !a.ariaFormat && (a.ariaFormat = a.format), Object.keys(c).forEach(function(e) {
              if (void 0 === a[e] && void 0 === d[e]) {
                  if (c[e].r) throw new Error("noUiSlider (" + $ + "): '" + e + "' is required.");
                  return !0
              }
              c[e].t(b, void 0 === a[e] ? d[e] : a[e])
          }), b.pips = a.pips;
          var e = [
              ["left", "top"],
              ["right", "bottom"]
          ];
          return b.style = e[b.dir][b.ort], b.styleOposite = e[b.dir ? 0 : 1][b.ort], b
      }
  
      function Y(a, e, g) {
          function k(a, b) {
              var c = xa.createElement("div");
              return b && l(c, b), a.appendChild(c), c
          }
  
          function s(a, b) {
              var c = k(a, e.cssClasses.origin),
                  d = k(c, e.cssClasses.handle);
              return d.setAttribute("data-handle", b), d.setAttribute("tabindex", "0"), d.setAttribute("role", "slider"), d.setAttribute("aria-orientation", e.ort ? "vertical" : "horizontal"), 0 === b ? l(d, e.cssClasses.handleLower) : b === e.handles - 1 && l(d, e.cssClasses.handleUpper), c
          }
  
          function t(a, b) {
              return b ? k(a, e.cssClasses.connect) : !1
          }
  
          function u(a, b) {
              ia = [], ja = [], ja.push(t(b, a[0]));
              for (var c = 0; c < e.handles; c++) ia.push(s(b, c)), ra[c] = c, ja.push(t(b, a[c + 1]))
          }
  
          function v(a) {
              l(a, e.cssClasses.target), 0 === e.dir ? l(a, e.cssClasses.ltr) : l(a, e.cssClasses.rtl), 0 === e.ort ? l(a, e.cssClasses.horizontal) : l(a, e.cssClasses.vertical), ha = k(a, e.cssClasses.base)
          }
  
          function w(a, b) {
              return e.tooltips[b] ? k(a.firstChild, e.cssClasses.tooltip) : !1
          }
  
          function x() {
              var a = ia.map(w);
              ea("update", function(b, c, d) {
                  if (a[c]) {
                      var f = b[c];
                      e.tooltips[c] !== !0 && (f = e.tooltips[c].to(d[c])), a[c].innerHTML = f
                  }
              })
          }
  
          function y() {
              ea("update", function(a, b, c, d, f) {
                  ra.forEach(function(a) {
                      var b = ia[a],
                          d = S(qa, a, 0, !0, !0, !0),
                          g = S(qa, a, 100, !0, !0, !0),
                          h = f[a],
                          i = e.ariaFormat.to(c[a]);
                      b.children[0].setAttribute("aria-valuemin", d.toFixed(1)), b.children[0].setAttribute("aria-valuemax", g.toFixed(1)), b.children[0].setAttribute("aria-valuenow", h.toFixed(1)), b.children[0].setAttribute("aria-valuetext", i)
                  })
              })
          }
  
          function z(a, b, c) {
              if ("range" === a || "steps" === a) return ta.xVal;
              if ("count" === a) {
                  if (!b) throw new Error("noUiSlider (" + $ + "): 'values' required for mode 'count'.");
                  var d, e = 100 / (b - 1),
                      f = 0;
                  for (b = [];
                      (d = f++ * e) <= 100;) b.push(d);
                  a = "positions"
              }
              return "positions" === a ? b.map(function(a) {
                  return ta.fromStepping(c ? ta.getStep(a) : a)
              }) : "values" === a ? c ? b.map(function(a) {
                  return ta.fromStepping(ta.getStep(ta.toStepping(a)))
              }) : b : void 0
          }
  
          function A(a, b, c) {
              function e(a, b) {
                  return (a + b).toFixed(7) / 1
              }
              var f = {},
                  g = ta.xVal[0],
                  h = ta.xVal[ta.xVal.length - 1],
                  i = !1,
                  j = !1,
                  k = 0;
              return c = d(c.slice().sort(function(a, b) {
                  return a - b
              })), c[0] !== g && (c.unshift(g), i = !0), c[c.length - 1] !== h && (c.push(h), j = !0), c.forEach(function(d, g) {
                  var h, l, m, n, o, p, q, r, s, t, u = d,
                      v = c[g + 1];
                  if ("steps" === b && (h = ta.xNumSteps[g]), h || (h = v - u), u !== !1 && void 0 !== v)
                      for (h = Math.max(h, 1e-7), l = u; v >= l; l = e(l, h)) {
                          for (n = ta.toStepping(l), o = n - k, r = o / a, s = Math.round(r), t = o / s, m = 1; s >= m; m += 1) p = k + m * t, f[p.toFixed(5)] = ["x", 0];
                          q = c.indexOf(l) > -1 ? 1 : "steps" === b ? 2 : 0, !g && i && (q = 0), l === v && j || (f[n.toFixed(5)] = [l, q]), k = n
                      }
              }), f
          }
  
          function B(a, b, c) {
              function d(a, b) {
                  var c = b === e.cssClasses.value,
                      d = c ? j : m,
                      f = c ? h : i;
                  return b + " " + d[e.ort] + " " + f[a]
              }
  
              function f(a, f) {
                  f[1] = f[1] && b ? b(f[0], f[1]) : f[1];
                  var h = k(g, !1);
                  h.className = d(f[1], e.cssClasses.marker), h.style[e.style] = a + "%", f[1] && (h = k(g, !1), h.className = d(f[1], e.cssClasses.value), h.style[e.style] = a + "%", h.innerText = c.to(f[0]))
              }
              var g = xa.createElement("div"),
                  h = [e.cssClasses.valueNormal, e.cssClasses.valueLarge, e.cssClasses.valueSub],
                  i = [e.cssClasses.markerNormal, e.cssClasses.markerLarge, e.cssClasses.markerSub],
                  j = [e.cssClasses.valueHorizontal, e.cssClasses.valueVertical],
                  m = [e.cssClasses.markerHorizontal, e.cssClasses.markerVertical];
              return l(g, e.cssClasses.pips), l(g, 0 === e.ort ? e.cssClasses.pipsHorizontal : e.cssClasses.pipsVertical), Object.keys(a).forEach(function(b) {
                  f(b, a[b])
              }), g
          }
  
          function C() {
              la && (b(la), la = null)
          }
  
          function D(a) {
              C();
              var b = a.mode,
                  c = a.density || 1,
                  d = a.filter || !1,
                  e = a.values || !1,
                  f = a.stepped || !1,
                  g = z(b, e, f),
                  h = A(c, b, g),
                  i = a.format || {
                      to: Math.round
                  };
              return la = pa.appendChild(B(h, d, i))
          }
  
          function E() {
              var a = ha.getBoundingClientRect(),
                  b = "offset" + ["Width", "Height"][e.ort];
              return 0 === e.ort ? a.width || ha[b] : a.height || ha[b]
          }
  
          function F(a, b, c, d) {
              var f = function(b) {
                      return pa.hasAttribute("disabled") ? !1 : n(pa, e.cssClasses.tap) ? !1 : (b = G(b, d.pageOffset)) ? a === ma.start && void 0 !== b.buttons && b.buttons > 1 ? !1 : d.hover && b.buttons ? !1 : (oa || b.preventDefault(), b.calcPoint = b.points[e.ort], void c(b, d)) : !1
                  },
                  g = [];
              return a.split(" ").forEach(function(a) {
                  b.addEventListener(a, f, oa ? {
                      passive: !0
                  } : !1), g.push([a, f])
              }), g
          }
  
          function G(a, b) {
              var c, d, e = 0 === a.type.indexOf("touch"),
                  f = 0 === a.type.indexOf("mouse"),
                  g = 0 === a.type.indexOf("pointer");
              if (0 === a.type.indexOf("MSPointer") && (g = !0), e) {
                  if (a.touches.length > 1) return !1;
                  c = a.changedTouches[0].pageX, d = a.changedTouches[0].pageY
              }
              return b = b || o(xa), (f || g) && (c = a.clientX + b.x, d = a.clientY + b.y), a.pageOffset = b, a.points = [c, d], a.cursor = f || g, a
          }
  
          function H(a) {
              var b = a - f(ha, e.ort),
                  c = 100 * b / E();
              return e.dir ? 100 - c : c
          }
  
          function I(a) {
              var b = 100,
                  c = !1;
              return ia.forEach(function(d, e) {
                  if (!d.hasAttribute("disabled")) {
                      var f = Math.abs(qa[e] - a);
                      b > f && (c = e, b = f)
                  }
              }), c
          }
  
          function J(a, b, c, d) {
              var e = c.slice(),
                  f = [!a, a],
                  g = [a, !a];
              d = d.slice(), a && d.reverse(), d.length > 1 ? d.forEach(function(a, c) {
                  var d = S(e, a, e[a] + b, f[c], g[c], !1);
                  d === !1 ? b = 0 : (b = d - e[a], e[a] = d)
              }) : f = g = [!0];
              var h = !1;
              d.forEach(function(a, d) {
                  h = W(a, c[a] + b, f[d], g[d]) || h
              }), h && d.forEach(function(a) {
                  K("update", a), K("slide", a)
              })
          }
  
          function K(a, b, c) {
              Object.keys(va).forEach(function(d) {
                  var f = d.split(".")[0];
                  a === f && va[d].forEach(function(a) {
                      a.call(ka, ua.map(e.format.to), b, ua.slice(), c || !1, qa.slice())
                  })
              })
          }
  
          function L(a, b) {
              "mouseout" === a.type && "HTML" === a.target.nodeName && null === a.relatedTarget && N(a, b)
          }
  
          function M(a, b) {
              if (-1 === navigator.appVersion.indexOf("MSIE 9") && 0 === a.buttons && 0 !== b.buttonsProperty) return N(a, b);
              var c = (e.dir ? -1 : 1) * (a.calcPoint - b.startCalcPoint),
                  d = 100 * c / b.baseSize;
              J(c > 0, d, b.locations, b.handleNumbers)
          }
  
          function N(a, b) {
              sa && (m(sa, e.cssClasses.active), sa = !1), a.cursor && (za.style.cursor = "", za.removeEventListener("selectstart", c)), wa.forEach(function(a) {
                  ya.removeEventListener(a[0], a[1])
              }), m(pa, e.cssClasses.drag), V(), b.handleNumbers.forEach(function(a) {
                  K("change", a), K("set", a), K("end", a)
              })
          }
  
          function O(a, b) {
              if (1 === b.handleNumbers.length) {
                  var d = ia[b.handleNumbers[0]];
                  if (d.hasAttribute("disabled")) return !1;
                  sa = d.children[0], l(sa, e.cssClasses.active)
              }
              a.stopPropagation();
              var f = F(ma.move, ya, M, {
                      startCalcPoint: a.calcPoint,
                      baseSize: E(),
                      pageOffset: a.pageOffset,
                      handleNumbers: b.handleNumbers,
                      buttonsProperty: a.buttons,
                      locations: qa.slice()
                  }),
                  g = F(ma.end, ya, N, {
                      handleNumbers: b.handleNumbers
                  }),
                  h = F("mouseout", ya, L, {
                      handleNumbers: b.handleNumbers
                  });
              wa = f.concat(g, h), a.cursor && (za.style.cursor = getComputedStyle(a.target).cursor, ia.length > 1 && l(pa, e.cssClasses.drag), za.addEventListener("selectstart", c, !1)), b.handleNumbers.forEach(function(a) {
                  K("start", a)
              })
          }
  
          function P(a) {
              a.stopPropagation();
              var b = H(a.calcPoint),
                  c = I(b);
              return c === !1 ? !1 : (e.events.snap || h(pa, e.cssClasses.tap, e.animationDuration), W(c, b, !0, !0), V(), K("slide", c, !0), K("update", c, !0), K("change", c, !0), K("set", c, !0), void(e.events.snap && O(a, {
                  handleNumbers: [c]
              })))
          }
  
          function Q(a) {
              var b = H(a.calcPoint),
                  c = ta.getStep(b),
                  d = ta.fromStepping(c);
              Object.keys(va).forEach(function(a) {
                  "hover" === a.split(".")[0] && va[a].forEach(function(a) {
                      a.call(ka, d)
                  })
              })
          }
  
          function R(a) {
              a.fixed || ia.forEach(function(a, b) {
                  F(ma.start, a.children[0], O, {
                      handleNumbers: [b]
                  })
              }), a.tap && F(ma.start, ha, P, {}), a.hover && F(ma.move, ha, Q, {
                  hover: !0
              }), a.drag && ja.forEach(function(b, c) {
                  if (b !== !1 && 0 !== c && c !== ja.length - 1) {
                      var d = ia[c - 1],
                          f = ia[c],
                          g = [b];
                      l(b, e.cssClasses.draggable), a.fixed && (g.push(d.children[0]), g.push(f.children[0])), g.forEach(function(a) {
                          F(ma.start, a, O, {
                              handles: [d, f],
                              handleNumbers: [c - 1, c]
                          })
                      })
                  }
              })
          }
  
          function S(a, b, c, d, f, g) {
              return ia.length > 1 && (d && b > 0 && (c = Math.max(c, a[b - 1] + e.margin)), f && b < ia.length - 1 && (c = Math.min(c, a[b + 1] - e.margin))), ia.length > 1 && e.limit && (d && b > 0 && (c = Math.min(c, a[b - 1] + e.limit)), f && b < ia.length - 1 && (c = Math.max(c, a[b + 1] - e.limit))), e.padding && (0 === b && (c = Math.max(c, e.padding)), b === ia.length - 1 && (c = Math.min(c, 100 - e.padding))), c = ta.getStep(c), c = i(c), c !== a[b] || g ? c : !1
          }
  
          function T(a) {
              return a + "%"
          }
  
          function U(a, b) {
              qa[a] = b, ua[a] = ta.fromStepping(b);
              var c = function() {
                  ia[a].style[e.style] = T(b), Y(a), Y(a + 1)
              };
              window.requestAnimationFrame && e.useRequestAnimationFrame ? window.requestAnimationFrame(c) : c()
          }
  
          function V() {
              ra.forEach(function(a) {
                  var b = qa[a] > 50 ? -1 : 1,
                      c = 3 + (ia.length + b * a);
                  ia[a].childNodes[0].style.zIndex = c
              })
          }
  
          function W(a, b, c, d) {
              return b = S(qa, a, b, c, d, !1), b === !1 ? !1 : (U(a, b), !0)
          }
  
          function Y(a) {
              if (ja[a]) {
                  var b = 0,
                      c = 100;
                  0 !== a && (b = qa[a - 1]), a !== ja.length - 1 && (c = qa[a]), ja[a].style[e.style] = T(b), ja[a].style[e.styleOposite] = T(100 - c)
              }
          }
  
          function Z(a, b) {
              null !== a && a !== !1 && ("number" == typeof a && (a = String(a)), a = e.format.from(a), a === !1 || isNaN(a) || W(b, ta.toStepping(a), !1, !1))
          }
  
          function _(a, b) {
              var c = j(a),
                  d = void 0 === qa[0];
              b = void 0 === b ? !0 : !!b, c.forEach(Z), e.animate && !d && h(pa, e.cssClasses.tap, e.animationDuration), ra.forEach(function(a) {
                  W(a, qa[a], !0, !1)
              }), V(), ra.forEach(function(a) {
                  K("update", a), null !== c[a] && b && K("set", a)
              })
          }
  
          function aa(a) {
              _(e.start, a)
          }
  
          function ba() {
              var a = ua.map(e.format.to);
              return 1 === a.length ? a[0] : a
          }
  
          function ca() {
              for (var a in e.cssClasses) e.cssClasses.hasOwnProperty(a) && m(pa, e.cssClasses[a]);
              for (; pa.firstChild;) pa.removeChild(pa.firstChild);
              delete pa.noUiSlider
          }
  
          function da() {
              return qa.map(function(a, b) {
                  var c = ta.getNearbySteps(a),
                      d = ua[b],
                      e = c.thisStep.step,
                      f = null;
                  e !== !1 && d + e > c.stepAfter.startValue && (e = c.stepAfter.startValue - d), f = d > c.thisStep.startValue ? c.thisStep.step : c.stepBefore.step === !1 ? !1 : d - c.stepBefore.highestStep, 100 === a ? e = null : 0 === a && (f = null);
                  var g = ta.countStepDecimals();
                  return null !== e && e !== !1 && (e = Number(e.toFixed(g))), null !== f && f !== !1 && (f = Number(f.toFixed(g))), [f, e]
              })
          }
  
          function ea(a, b) {
              va[a] = va[a] || [], va[a].push(b), "update" === a.split(".")[0] && ia.forEach(function(a, b) {
                  K("update", b)
              })
          }
  
          function fa(a) {
              var b = a && a.split(".")[0],
                  c = b && a.substring(b.length);
              Object.keys(va).forEach(function(a) {
                  var d = a.split(".")[0],
                      e = a.substring(d.length);
                  b && b !== d || c && c !== e || delete va[a]
              })
          }
  
          function ga(a, b) {
              var c = ba(),
                  d = ["margin", "limit", "padding", "range", "animate", "snap", "step", "format"];
              d.forEach(function(b) {
                  void 0 !== a[b] && (g[b] = a[b])
              });
              var f = X(g);
              d.forEach(function(b) {
                  void 0 !== a[b] && (e[b] = f[b])
              }), ta = f.spectrum, e.margin = f.margin, e.limit = f.limit, e.padding = f.padding, e.pips && D(e.pips), qa = [], _(a.start || c, b)
          }
          var ha, ia, ja, ka, la, ma = p(),
              na = r(),
              oa = na && q(),
              pa = a,
              qa = [],
              ra = [],
              sa = !1,
              ta = e.spectrum,
              ua = [],
              va = {},
              wa = null,
              xa = a.ownerDocument,
              ya = xa.documentElement,
              za = xa.body;
          if (pa.noUiSlider) throw new Error("noUiSlider (" + $ + "): Slider was already initialized.");
          return v(pa), u(e.connect, ha), ka = {
              destroy: ca,
              steps: da,
              on: ea,
              off: fa,
              get: ba,
              set: _,
              reset: aa,
              __moveHandles: function(a, b, c) {
                  J(a, b, qa, c)
              },
              options: g,
              updateOptions: ga,
              target: pa,
              removePips: C,
              pips: D
          }, R(e.events), _(e.start), e.pips && D(e.pips), e.tooltips && x(), y(), ka
      }
  
      function Z(a, b) {
          if (!a || !a.nodeName) throw new Error("noUiSlider (" + $ + "): create requires a single element, got: " + a);
          var c = X(b, a),
              d = Y(a, c, b);
          return a.noUiSlider = d, d
      }
      var $ = "10.0.0";
      C.prototype.getMargin = function(a) {
          var b = this.xNumSteps[0];
          if (b && a / b % 1 !== 0) throw new Error("noUiSlider (" + $ + "): 'limit', 'margin' and 'padding' must be divisible by step.");
          return 2 === this.xPct.length ? t(this.xVal, a) : !1
      }, C.prototype.toStepping = function(a) {
          return a = x(this.xVal, this.xPct, a)
      }, C.prototype.fromStepping = function(a) {
          return y(this.xVal, this.xPct, a)
      }, C.prototype.getStep = function(a) {
          return a = z(this.xPct, this.xSteps, this.snap, a)
      }, C.prototype.getNearbySteps = function(a) {
          var b = w(a, this.xPct);
          return {
              stepBefore: {
                  startValue: this.xVal[b - 2],
                  step: this.xNumSteps[b - 2],
                  highestStep: this.xHighestCompleteStep[b - 2]
              },
              thisStep: {
                  startValue: this.xVal[b - 1],
                  step: this.xNumSteps[b - 1],
                  highestStep: this.xHighestCompleteStep[b - 1]
              },
              stepAfter: {
                  startValue: this.xVal[b - 0],
                  step: this.xNumSteps[b - 0],
                  highestStep: this.xHighestCompleteStep[b - 0]
              }
          }
      }, C.prototype.countStepDecimals = function() {
          var a = this.xNumSteps.map(k);
          return Math.max.apply(null, a)
      }, C.prototype.convert = function(a) {
          return this.getStep(this.toStepping(a))
      };
      var _ = {
          to: function(a) {
              return void 0 !== a && a.toFixed(2)
          },
          from: Number
      };
      return {
          version: $,
          create: Z
      }
  });