 /**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0-alpha.6): tooltip.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/

var Tooltip = function ($) {

 /**
  * Check for Tether dependency
  * Tether - http://tether.io/
  */
 if (typeof Tether === 'undefined') {
   throw new Error('Bootstrap tooltips require Tether (http://tether.io/)');
 }

 /**
  * ------------------------------------------------------------------------
  * Constants
  * ------------------------------------------------------------------------
  */

 var NAME = 'tooltip';
 var VERSION = '4.0.0-alpha.6';
 var DATA_KEY = 'bs.tooltip';
 var EVENT_KEY = '.' + DATA_KEY;
 var JQUERY_NO_CONFLICT = $.fn[NAME];
 var TRANSITION_DURATION = 150;
 var CLASS_PREFIX = 'bs-tether';

 var Default = {
   animation: true,
   template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-inner"></div></div>',
   trigger: 'hover focus',
   title: '',
   delay: 0,
   html: false,
   selector: false,
   placement: 'top',
   offset: '0 0',
   constraints: [],
   container: false
 };

 var DefaultType = {
   animation: 'boolean',
   template: 'string',
   title: '(string|element|function)',
   trigger: 'string',
   delay: '(number|object)',
   html: 'boolean',
   selector: '(string|boolean)',
   placement: '(string|function)',
   offset: 'string',
   constraints: 'array',
   container: '(string|element|boolean)'
 };

 var AttachmentMap = {
   TOP: 'bottom center',
   RIGHT: 'middle left',
   BOTTOM: 'top center',
   LEFT: 'middle right'
 };

 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'
 };

 var TetherClass = {
   element: false,
   enabled: false
 };

 var Trigger = {
   HOVER: 'hover',
   FOCUS: 'focus',
   CLICK: 'click',
   MANUAL: 'manual'
 };

 /**
  * ------------------------------------------------------------------------
  * Class Definition
  * ------------------------------------------------------------------------
  */

 var Tooltip = function () {
   function Tooltip(element, config) {
     _classCallCheck(this, Tooltip);

     // private
     this._isEnabled = true;
     this._timeout = 0;
     this._hoverState = '';
     this._activeTrigger = {};
     this._isTransitioning = false;
     this._tether = null;

     // protected
     this.element = element;
     this.config = this._getConfig(config);
     this.tip = null;

     this._setListeners();
   }

   // getters

   // public

   Tooltip.prototype.enable = function enable() {
     this._isEnabled = true;
   };

   Tooltip.prototype.disable = function disable() {
     this._isEnabled = false;
   };

   Tooltip.prototype.toggleEnabled = function toggleEnabled() {
     this._isEnabled = !this._isEnabled;
   };

   Tooltip.prototype.toggle = function toggle(event) {
     if (event) {
       var dataKey = this.constructor.DATA_KEY;
       var context = $(event.currentTarget).data(dataKey);

       if (!context) {
         context = new this.constructor(event.currentTarget, this._getDelegateConfig());
         $(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 ($(this.getTipElement()).hasClass(ClassName.SHOW)) {
         this._leave(null, this);
         return;
       }

       this._enter(null, this);
     }
   };

   Tooltip.prototype.dispose = function dispose() {
     clearTimeout(this._timeout);

     this.cleanupTether();

     $.removeData(this.element, this.constructor.DATA_KEY);

     $(this.element).off(this.constructor.EVENT_KEY);
     $(this.element).closest('.modal').off('hide.bs.modal');

     if (this.tip) {
       $(this.tip).remove();
     }

     this._isEnabled = null;
     this._timeout = null;
     this._hoverState = null;
     this._activeTrigger = null;
     this._tether = null;

     this.element = null;
     this.config = null;
     this.tip = null;
   };

   Tooltip.prototype.show = function show() {
     var _this22 = this;

     if ($(this.element).css('display') === 'none') {
       throw new Error('Please use show on visible elements');
     }

     var showEvent = $.Event(this.constructor.Event.SHOW);
     if (this.isWithContent() && this._isEnabled) {
       if (this._isTransitioning) {
         throw new Error('Tooltip is transitioning');
       }
       $(this.element).trigger(showEvent);

       var isInTheDom = $.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) {
         $(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);

       var container = this.config.container === false ? document.body : $(this.config.container);

       $(tip).data(this.constructor.DATA_KEY, this).appendTo(container);

       $(this.element).trigger(this.constructor.Event.INSERTED);

       this._tether = new Tether({
         attachment: attachment,
         element: tip,
         target: this.element,
         classes: TetherClass,
         classPrefix: CLASS_PREFIX,
         offset: this.config.offset,
         constraints: this.config.constraints,
         addTargetClasses: false
       });

       Util.reflow(tip);
       this._tether.position();

       $(tip).addClass(ClassName.SHOW);

       var complete = function complete() {
         var prevHoverState = _this22._hoverState;
         _this22._hoverState = null;
         _this22._isTransitioning = false;

         $(_this22.element).trigger(_this22.constructor.Event.SHOWN);

         if (prevHoverState === HoverState.OUT) {
           _this22._leave(null, _this22);
         }
       };

       if (Util.supportsTransitionEnd() && $(this.tip).hasClass(ClassName.FADE)) {
         this._isTransitioning = true;
         $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION);
         return;
       }

       complete();
     }
   };

   Tooltip.prototype.hide = function hide(callback) {
     var _this23 = this;

     var tip = this.getTipElement();
     var hideEvent = $.Event(this.constructor.Event.HIDE);
     if (this._isTransitioning) {
       throw new Error('Tooltip is transitioning');
     }
     var complete = function complete() {
       if (_this23._hoverState !== HoverState.SHOW && tip.parentNode) {
         tip.parentNode.removeChild(tip);
       }

       _this23.element.removeAttribute('aria-describedby');
       $(_this23.element).trigger(_this23.constructor.Event.HIDDEN);
       _this23._isTransitioning = false;
       _this23.cleanupTether();

       if (callback) {
         callback();
       }
     };

     $(this.element).trigger(hideEvent);

     if (hideEvent.isDefaultPrevented()) {
       return;
     }

     $(tip).removeClass(ClassName.SHOW);

     this._activeTrigger[Trigger.CLICK] = false;
     this._activeTrigger[Trigger.FOCUS] = false;
     this._activeTrigger[Trigger.HOVER] = false;

     if (Util.supportsTransitionEnd() && $(this.tip).hasClass(ClassName.FADE)) {
       this._isTransitioning = true;
       $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
     } else {
       complete();
     }

     this._hoverState = '';
   };

   // protected

   Tooltip.prototype.isWithContent = function isWithContent() {
     return Boolean(this.getTitle());
   };

   Tooltip.prototype.getTipElement = function getTipElement() {
     return this.tip = this.tip || $(this.config.template)[0];
   };

   Tooltip.prototype.setContent = function setContent() {
     var $tip = $(this.getTipElement());

     this.setElementContent($tip.find(Selector.TOOLTIP_INNER), this.getTitle());

     $tip.removeClass(ClassName.FADE + ' ' + ClassName.SHOW);

     this.cleanupTether();
   };

   Tooltip.prototype.setElementContent = function setElementContent($element, content) {
     var html = this.config.html;
     if ((typeof content === 'undefined' ? 'undefined' : _typeof(content)) === 'object' && (content.nodeType || content.jquery)) {
       // content is a DOM node or a jQuery
       if (html) {
         if (!$(content).parent().is($element)) {
           $element.empty().append(content);
         }
       } else {
         $element.text($(content).text());
       }
     } else {
       $element[html ? 'html' : 'text'](content);
     }
   };

   Tooltip.prototype.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;
   };

   Tooltip.prototype.cleanupTether = function cleanupTether() {
     if (this._tether) {
       this._tether.destroy();
     }
   };

   // private

   Tooltip.prototype._getAttachment = function _getAttachment(placement) {
     return AttachmentMap[placement.toUpperCase()];
   };

   Tooltip.prototype._setListeners = function _setListeners() {
     var _this24 = this;

     var triggers = this.config.trigger.split(' ');

     triggers.forEach(function (trigger) {
       if (trigger === 'click') {
         $(_this24.element).on(_this24.constructor.Event.CLICK, _this24.config.selector, function (event) {
           return _this24.toggle(event);
         });
       } else if (trigger !== Trigger.MANUAL) {
         var eventIn = trigger === Trigger.HOVER ? _this24.constructor.Event.MOUSEENTER : _this24.constructor.Event.FOCUSIN;
         var eventOut = trigger === Trigger.HOVER ? _this24.constructor.Event.MOUSELEAVE : _this24.constructor.Event.FOCUSOUT;

         $(_this24.element).on(eventIn, _this24.config.selector, function (event) {
           return _this24._enter(event);
         }).on(eventOut, _this24.config.selector, function (event) {
           return _this24._leave(event);
         });
       }

       $(_this24.element).closest('.modal').on('hide.bs.modal', function () {
         return _this24.hide();
       });
     });

     if (this.config.selector) {
       this.config = $.extend({}, this.config, {
         trigger: 'manual',
         selector: ''
       });
     } else {
       this._fixTitle();
     }
   };

   Tooltip.prototype._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', '');
     }
   };

   Tooltip.prototype._enter = function _enter(event, context) {
     var dataKey = this.constructor.DATA_KEY;

     context = context || $(event.currentTarget).data(dataKey);

     if (!context) {
       context = new this.constructor(event.currentTarget, this._getDelegateConfig());
       $(event.currentTarget).data(dataKey, context);
     }

     if (event) {
       context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
     }

     if ($(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);
   };

   Tooltip.prototype._leave = function _leave(event, context) {
     var dataKey = this.constructor.DATA_KEY;

     context = context || $(event.currentTarget).data(dataKey);

     if (!context) {
       context = new this.constructor(event.currentTarget, this._getDelegateConfig());
       $(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);
   };

   Tooltip.prototype._isWithActiveTrigger = function _isWithActiveTrigger() {
     for (var trigger in this._activeTrigger) {
       if (this._activeTrigger[trigger]) {
         return true;
       }
     }

     return false;
   };

   Tooltip.prototype._getConfig = function _getConfig(config) {
     config = $.extend({}, this.constructor.Default, $(this.element).data(), config);

     if (config.delay && typeof config.delay === 'number') {
       config.delay = {
         show: config.delay,
         hide: config.delay
       };
     }

     Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);

     return config;
   };

   Tooltip.prototype._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;
   };

   // static

   Tooltip._jQueryInterface = function _jQueryInterface(config) {
     return this.each(function () {
       var data = $(this).data(DATA_KEY);
       var _config = (typeof config === 'undefined' ? 'undefined' : _typeof(config)) === 'object' && config;

       if (!data && /dispose|hide/.test(config)) {
         return;
       }

       if (!data) {
         data = new Tooltip(this, _config);
         $(this).data(DATA_KEY, data);
       }

       if (typeof config === 'string') {
         if (data[config] === undefined) {
           throw new Error('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
  * ------------------------------------------------------------------------
  */

 $.fn[NAME] = Tooltip._jQueryInterface;
 $.fn[NAME].Constructor = Tooltip;
 $.fn[NAME].noConflict = function () {
   $.fn[NAME] = JQUERY_NO_CONFLICT;
   return Tooltip._jQueryInterface;
 };

 return Tooltip;
}(jQuery);
