/*!

 * jQuery UI Tooltip 1.13.3

 * https://jqueryui.com

 *

 * Copyright OpenJS Foundation and other contributors

 * Released under the MIT license.

 * https://jquery.org/license

 */

//>>label: Tooltip

//>>group: Widgets

//>>description: Shows additional information for any element on hover or focus.

//>>docs: https://api.jqueryui.com/tooltip/

//>>demos: https://jqueryui.com/tooltip/

//>>css.structure: ../../themes/base/core.css

//>>css.structure: ../../themes/base/tooltip.css

//>>css.theme: ../../themes/base/theme.css

( function( factory ) {

	"use strict";

	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"../keycode",

			"../position",

			"../unique-id",

			"../version",

			"../widget"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

$.widget( "ui.tooltip", {

	version: "1.13.3",

	options: {

		classes: {

			"ui-tooltip": "ui-corner-all ui-widget-shadow"

		},

		content: function() {

			var title = $( this ).attr( "title" );

			// Escape title, since we're going from an attribute to raw HTML

			return $( "<a>" ).text( title ).html();

		},

		hide: true,

		// Disabled elements have inconsistent behavior across browsers (#8661)

		items: "[title]:not([disabled])",

		position: {

			my: "left top+15",

			at: "left bottom",

			collision: "flipfit flip"

		},

		show: true,

		track: false,

		// Callbacks

		close: null,

		open: null

	},

	_addDescribedBy: function( elem, id ) {

		var describedby = ( elem.attr( "aria-describedby" ) || "" ).split( /\s+/ );

		describedby.push( id );

		elem

			.data( "ui-tooltip-id", id )

			.attr( "aria-describedby", String.prototype.trim.call( describedby.join( " " ) ) );

	},

	_removeDescribedBy: function( elem ) {

		var id = elem.data( "ui-tooltip-id" ),

			describedby = ( elem.attr( "aria-describedby" ) || "" ).split( /\s+/ ),

			index = $.inArray( id, describedby );

		if ( index !== -1 ) {

			describedby.splice( index, 1 );

		}

		elem.removeData( "ui-tooltip-id" );

		describedby = String.prototype.trim.call( describedby.join( " " ) );

		if ( describedby ) {

			elem.attr( "aria-describedby", describedby );

		} else {

			elem.removeAttr( "aria-describedby" );

		}

	},

	_create: function() {

		this._on( {

			mouseover: "open",

			focusin: "open"

		} );

		// IDs of generated tooltips, needed for destroy

		this.tooltips = {};

		// IDs of parent tooltips where we removed the title attribute

		this.parents = {};

		// Append the aria-live region so tooltips announce correctly

		this.liveRegion = $( "<div>" )

			.attr( {

				role: "log",

				"aria-live": "assertive",

				"aria-relevant": "additions"

			} )

			.appendTo( this.document[ 0 ].body );

		this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );

		this.disabledTitles = $( [] );

	},

	_setOption: function( key, value ) {

		var that = this;

		this._super( key, value );

		if ( key === "content" ) {

			$.each( this.tooltips, function( id, tooltipData ) {

				that._updateContent( tooltipData.element );

			} );

		}

	},

	_setOptionDisabled: function( value ) {

		this[ value ? "_disable" : "_enable" ]();

	},

	_disable: function() {

		var that = this;

		// Close open tooltips

		$.each( this.tooltips, function( id, tooltipData ) {

			var event = $.Event( "blur" );

			event.target = event.currentTarget = tooltipData.element[ 0 ];

			that.close( event, true );

		} );

		// Remove title attributes to prevent native tooltips

		this.disabledTitles = this.disabledTitles.add(

			this.element.find( this.options.items ).addBack()

				.filter( function() {

					var element = $( this );

					if ( element.is( "[title]" ) ) {

						return element

							.data( "ui-tooltip-title", element.attr( "title" ) )

							.removeAttr( "title" );

					}

				} )

		);

	},

	_enable: function() {

		// restore title attributes

		this.disabledTitles.each( function() {

			var element = $( this );

			if ( element.data( "ui-tooltip-title" ) ) {

				element.attr( "title", element.data( "ui-tooltip-title" ) );

			}

		} );

		this.disabledTitles = $( [] );

	},

	open: function( event ) {

		var that = this,

			target = $( event ? event.target : this.element )

				// we need closest here due to mouseover bubbling,

				// but always pointing at the same event target

				.closest( this.options.items );

		// No element to show a tooltip for or the tooltip is already open

		if ( !target.length || target.data( "ui-tooltip-id" ) ) {

			return;

		}

		if ( target.attr( "title" ) ) {

			target.data( "ui-tooltip-title", target.attr( "title" ) );

		}

		target.data( "ui-tooltip-open", true );

		// Kill parent tooltips, custom or native, for hover

		if ( event && event.type === "mouseover" ) {

			target.parents().each( function() {

				var parent = $( this ),

					blurEvent;

				if ( parent.data( "ui-tooltip-open" ) ) {

					blurEvent = $.Event( "blur" );

					blurEvent.target = blurEvent.currentTarget = this;

					that.close( blurEvent, true );

				}

				if ( parent.attr( "title" ) ) {

					parent.uniqueId();

					that.parents[ this.id ] = {

						element: this,

						title: parent.attr( "title" )

					};

					parent.attr( "title", "" );

				}

			} );

		}

		this._registerCloseHandlers( event, target );

		this._updateContent( target, event );

	},

	_updateContent: function( target, event ) {

		var content,

			contentOption = this.options.content,

			that = this,

			eventType = event ? event.type : null;

		if ( typeof contentOption === "string" || contentOption.nodeType ||

				contentOption.jquery ) {

			return this._open( event, target, contentOption );

		}

		content = contentOption.call( target[ 0 ], function( response ) {

			// IE may instantly serve a cached response for ajax requests

			// delay this call to _open so the other call to _open runs first

			that._delay( function() {

				// Ignore async response if tooltip was closed already

				if ( !target.data( "ui-tooltip-open" ) ) {

					return;

				}

				// JQuery creates a special event for focusin when it doesn't

				// exist natively. To improve performance, the native event

				// object is reused and the type is changed. Therefore, we can't

				// rely on the type being correct after the event finished

				// bubbling, so we set it back to the previous value. (#8740)

				if ( event ) {

					event.type = eventType;

				}

				this._open( event, target, response );

			} );

		} );

		if ( content ) {

			this._open( event, target, content );

		}

	},

	_open: function( event, target, content ) {

		var tooltipData, tooltip, delayedShow, a11yContent,

			positionOption = $.extend( {}, this.options.position );

		if ( !content ) {

			return;

		}

		// Content can be updated multiple times. If the tooltip already

		// exists, then just update the content and bail.

		tooltipData = this._find( target );

		if ( tooltipData ) {

			tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );

			return;

		}

		// If we have a title, clear it to prevent the native tooltip

		// we have to check first to avoid defining a title if none exists

		// (we don't want to cause an element to start matching [title])

		//

		// We use removeAttr only for key events, to allow IE to export the correct

		// accessible attributes. For mouse events, set to empty string to avoid

		// native tooltip showing up (happens only when removing inside mouseover).

		if ( target.is( "[title]" ) ) {

			if ( event && event.type === "mouseover" ) {

				target.attr( "title", "" );

			} else {

				target.removeAttr( "title" );

			}

		}

		tooltipData = this._tooltip( target );

		tooltip = tooltipData.tooltip;

		this._addDescribedBy( target, tooltip.attr( "id" ) );

		tooltip.find( ".ui-tooltip-content" ).html( content );

		// Support: Voiceover on OS X, JAWS on IE <= 9

		// JAWS announces deletions even when aria-relevant="additions"

		// Voiceover will sometimes re-read the entire log region's contents from the beginning

		this.liveRegion.children().hide();

		a11yContent = $( "<div>" ).html( tooltip.find( ".ui-tooltip-content" ).html() );

		a11yContent.removeAttr( "name" ).find( "[name]" ).removeAttr( "name" );

		a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );

		a11yContent.appendTo( this.liveRegion );

		function position( event ) {

			positionOption.of = event;

			if ( tooltip.is( ":hidden" ) ) {

				return;

			}

			tooltip.position( positionOption );

		}

		if ( this.options.track && event && /^mouse/.test( event.type ) ) {

			this._on( this.document, {

				mousemove: position

			} );

			// trigger once to override element-relative positioning

			position( event );

		} else {

			tooltip.position( $.extend( {

				of: target

			}, this.options.position ) );

		}

		tooltip.hide();

		this._show( tooltip, this.options.show );

		// Handle tracking tooltips that are shown with a delay (#8644). As soon

		// as the tooltip is visible, position the tooltip using the most recent

		// event.

		// Adds the check to add the timers only when both delay and track options are set (#14682)

		if ( this.options.track && this.options.show && this.options.show.delay ) {

			delayedShow = this.delayedShow = setInterval( function() {

				if ( tooltip.is( ":visible" ) ) {

					position( positionOption.of );

					clearInterval( delayedShow );

				}

			}, 13 );

		}

		this._trigger( "open", event, { tooltip: tooltip } );

	},

	_registerCloseHandlers: function( event, target ) {

		var events = {

			keyup: function( event ) {

				if ( event.keyCode === $.ui.keyCode.ESCAPE ) {

					var fakeEvent = $.Event( event );

					fakeEvent.currentTarget = target[ 0 ];

					this.close( fakeEvent, true );

				}

			}

		};

		// Only bind remove handler for delegated targets. Non-delegated

		// tooltips will handle this in destroy.

		if ( target[ 0 ] !== this.element[ 0 ] ) {

			events.remove = function() {

				var targetElement = this._find( target );

				if ( targetElement ) {

					this._removeTooltip( targetElement.tooltip );

				}