?<h3>D¨ızenle: tooltip.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/*!
 * jQuery UI Tooltip 1.13.3
 * https://jqueryui.com
 *
 * Copyright OpenJS Foundation and other contributors
 * Released under the MIT license.
 * https://jquery.org/license
 */

//&gt;&gt;label: Tooltip
//&gt;&gt;group: Widgets
//&gt;&gt;description: Shows additional information for any element on hover or focus.
//&gt;&gt;docs: https://api.jqueryui.com/tooltip/
//&gt;&gt;demos: https://jqueryui.com/tooltip/
//&gt;&gt;css.structure: ../../themes/base/core.css
//&gt;&gt;css.structure: ../../themes/base/tooltip.css
//&gt;&gt;css.theme: ../../themes/base/theme.css

( function( factory ) {
	&quot;use strict&quot;;

	if ( typeof define === &quot;function&quot; &amp;&amp; define.amd ) {

		// AMD. Register as an anonymous module.
		define( [
			&quot;jquery&quot;,
			&quot;../keycode&quot;,
			&quot;../position&quot;,
			&quot;../unique-id&quot;,
			&quot;../version&quot;,
			&quot;../widget&quot;
		], factory );
	} else {

		// Browser globals
		factory( jQuery );
	}
} )( function( $ ) {
&quot;use strict&quot;;

$.widget( &quot;ui.tooltip&quot;, {
	version: &quot;1.13.3&quot;,
	options: {
		classes: {
			&quot;ui-tooltip&quot;: &quot;ui-corner-all ui-widget-shadow&quot;
		},
		content: function() {
			var title = $( this ).attr( &quot;title&quot; );

			// Escape title, since we&#039;re going from an attribute to raw HTML
			return $( &quot;&lt;a&gt;&quot; ).text( title ).html();
		},
		hide: true,

		// Disabled elements have inconsistent behavior across browsers (#8661)
		items: &quot;[title]:not([disabled])&quot;,
		position: {
			my: &quot;left top+15&quot;,
			at: &quot;left bottom&quot;,
			collision: &quot;flipfit flip&quot;
		},
		show: true,
		track: false,

		// Callbacks
		close: null,
		open: null
	},

	_addDescribedBy: function( elem, id ) {
		var describedby = ( elem.attr( &quot;aria-describedby&quot; ) || &quot;&quot; ).split( /\s+/ );
		describedby.push( id );
		elem
			.data( &quot;ui-tooltip-id&quot;, id )
			.attr( &quot;aria-describedby&quot;, String.prototype.trim.call( describedby.join( &quot; &quot; ) ) );
	},

	_removeDescribedBy: function( elem ) {
		var id = elem.data( &quot;ui-tooltip-id&quot; ),
			describedby = ( elem.attr( &quot;aria-describedby&quot; ) || &quot;&quot; ).split( /\s+/ ),
			index = $.inArray( id, describedby );

		if ( index !== -1 ) {
			describedby.splice( index, 1 );
		}

		elem.removeData( &quot;ui-tooltip-id&quot; );
		describedby = String.prototype.trim.call( describedby.join( &quot; &quot; ) );
		if ( describedby ) {
			elem.attr( &quot;aria-describedby&quot;, describedby );
		} else {
			elem.removeAttr( &quot;aria-describedby&quot; );
		}
	},

	_create: function() {
		this._on( {
			mouseover: &quot;open&quot;,
			focusin: &quot;open&quot;
		} );

		// 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 = $( &quot;&lt;div&gt;&quot; )
			.attr( {
				role: &quot;log&quot;,
				&quot;aria-live&quot;: &quot;assertive&quot;,
				&quot;aria-relevant&quot;: &quot;additions&quot;
			} )
			.appendTo( this.document[ 0 ].body );
		this._addClass( this.liveRegion, null, &quot;ui-helper-hidden-accessible&quot; );

		this.disabledTitles = $( [] );
	},

	_setOption: function( key, value ) {
		var that = this;

		this._super( key, value );

		if ( key === &quot;content&quot; ) {
			$.each( this.tooltips, function( id, tooltipData ) {
				that._updateContent( tooltipData.element );
			} );
		}
	},

	_setOptionDisabled: function( value ) {
		this[ value ? &quot;_disable&quot; : &quot;_enable&quot; ]();
	},

	_disable: function() {
		var that = this;

		// Close open tooltips
		$.each( this.tooltips, function( id, tooltipData ) {
			var event = $.Event( &quot;blur&quot; );
			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( &quot;[title]&quot; ) ) {
						return element
							.data( &quot;ui-tooltip-title&quot;, element.attr( &quot;title&quot; ) )
							.removeAttr( &quot;title&quot; );
					}
				} )
		);
	},

	_enable: function() {

		// restore title attributes
		this.disabledTitles.each( function() {
			var element = $( this );
			if ( element.data( &quot;ui-tooltip-title&quot; ) ) {
				element.attr( &quot;title&quot;, element.data( &quot;ui-tooltip-title&quot; ) );
			}
		} );
		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( &quot;ui-tooltip-id&quot; ) ) {
			return;
		}

		if ( target.attr( &quot;title&quot; ) ) {
			target.data( &quot;ui-tooltip-title&quot;, target.attr( &quot;title&quot; ) );
		}

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

		// Kill parent tooltips, custom or native, for hover
		if ( event &amp;&amp; event.type === &quot;mouseover&quot; ) {
			target.parents().each( function() {
				var parent = $( this ),
					blurEvent;
				if ( parent.data( &quot;ui-tooltip-open&quot; ) ) {
					blurEvent = $.Event( &quot;blur&quot; );
					blurEvent.target = blurEvent.currentTarget = this;
					that.close( blurEvent, true );
				}
				if ( parent.attr( &quot;title&quot; ) ) {
					parent.uniqueId();
					that.parents[ this.id ] = {
						element: this,
						title: parent.attr( &quot;title&quot; )
					};
					parent.attr( &quot;title&quot;, &quot;&quot; );
				}
			} );
		}

		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 === &quot;string&quot; || 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( &quot;ui-tooltip-open&quot; ) ) {
					return;
				}

				// JQuery creates a special event for focusin when it doesn&#039;t
				// exist natively. To improve performance, the native event
				// object is reused and the type is changed. Therefore, we can&#039;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( &quot;.ui-tooltip-content&quot; ).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&#039;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( &quot;[title]&quot; ) ) {
			if ( event &amp;&amp; event.type === &quot;mouseover&quot; ) {
				target.attr( &quot;title&quot;, &quot;&quot; );
			} else {
				target.removeAttr( &quot;title&quot; );
			}
		}

		tooltipData = this._tooltip( target );
		tooltip = tooltipData.tooltip;
		this._addDescribedBy( target, tooltip.attr( &quot;id&quot; ) );
		tooltip.find( &quot;.ui-tooltip-content&quot; ).html( content );

		// Support: Voiceover on OS X, JAWS on IE &lt;= 9
		// JAWS announces deletions even when aria-relevant=&quot;additions&quot;
		// Voiceover will sometimes re-read the entire log region&#039;s contents from the beginning
		this.liveRegion.children().hide();
		a11yContent = $( &quot;&lt;div&gt;&quot; ).html( tooltip.find( &quot;.ui-tooltip-content&quot; ).html() );
		a11yContent.removeAttr( &quot;name&quot; ).find( &quot;[name]&quot; ).removeAttr( &quot;name&quot; );
		a11yContent.removeAttr( &quot;id&quot; ).find( &quot;[id]&quot; ).removeAttr( &quot;id&quot; );
		a11yContent.appendTo( this.liveRegion );

		function position( event ) {
			positionOption.of = event;
			if ( tooltip.is( &quot;:hidden&quot; ) ) {
				return;
			}
			tooltip.position( positionOption );
		}
		if ( this.options.track &amp;&amp; event &amp;&amp; /^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 &amp;&amp; this.options.show &amp;&amp; this.options.show.delay ) {
			delayedShow = this.delayedShow = setInterval( function() {
				if ( tooltip.is( &quot;:visible&quot; ) ) {
					position( positionOption.of );
					clearInterval( delayedShow );
				}
			}, 13 );
		}

		this._trigger( &quot;open&quot;, 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 );
				}
			};
		}

		if ( !event || event.type === &quot;mouseover&quot; ) {
			events.mouseleave = &quot;close&quot;;
		}
		if ( !event || event.type === &quot;focusin&quot; ) {
			events.focusout = &quot;close&quot;;
		}
		this._on( true, target, events );
	},

	close: function( event ) {
		var tooltip,
			that = this,
			target = $( event ? event.currentTarget : this.element ),
			tooltipData = this._find( target );

		// The tooltip may already be closed
		if ( !tooltipData ) {

			// We set ui-tooltip-open immediately upon open (in open()), but only set the
			// additional data once there&#039;s actually content to show (in _open()). So even if the
			// tooltip doesn&#039;t have full data, we always remove ui-tooltip-open in case we&#039;re in
			// the period between open() and _open().
			target.removeData( &quot;ui-tooltip-open&quot; );
			return;
		}

		tooltip = tooltipData.tooltip;

		// Disabling closes the tooltip, so we need to track when we&#039;re closing
		// to avoid an infinite loop in case the tooltip becomes disabled on close
		if ( tooltipData.closing ) {
			return;
		}

		// Clear the interval for delayed tracking tooltips
		clearInterval( this.delayedShow );

		// Only set title if we had one before (see comment in _open())
		// If the title attribute has changed since open(), don&#039;t restore
		if ( target.data( &quot;ui-tooltip-title&quot; ) &amp;&amp; !target.attr( &quot;title&quot; ) ) {
			target.attr( &quot;title&quot;, target.data( &quot;ui-tooltip-title&quot; ) );
		}

		this._removeDescribedBy( target );

		tooltipData.hiding = true;
		tooltip.stop( true );
		this._hide( tooltip, this.options.hide, function() {
			that._removeTooltip( $( this ) );
		} );

		target.removeData( &quot;ui-tooltip-open&quot; );
		this._off( target, &quot;mouseleave focusout keyup&quot; );

		// Remove &#039;remove&#039; binding only on delegated targets
		if ( target[ 0 ] !== this.element[ 0 ] ) {
			this._off( target, &quot;remove&quot; );
		}
		this._off( this.document, &quot;mousemove&quot; );

		if ( event &amp;&amp; event.type === &quot;mouseleave&quot; ) {
			$.each( this.parents, function( id, parent ) {
				$( parent.element ).attr( &quot;title&quot;, parent.title );
				delete that.parents[ id ];
			} );
		}

		tooltipData.closing = true;
		this._trigger( &quot;close&quot;, event, { tooltip: tooltip } );
		if ( !tooltipData.hiding ) {
			tooltipData.closing = false;
		}
	},

	_tooltip: function( element ) {
		var tooltip = $( &quot;&lt;div&gt;&quot; ).attr( &quot;role&quot;, &quot;tooltip&quot; ),
			content = $( &quot;&lt;div&gt;&quot; ).appendTo( tooltip ),
			id = tooltip.uniqueId().attr( &quot;id&quot; );

		this._addClass( content, &quot;ui-tooltip-content&quot; );
		this._addClass( tooltip, &quot;ui-tooltip&quot;, &quot;ui-widget ui-widget-content&quot; );

		tooltip.appendTo( this._appendTo( element ) );

		return this.tooltips[ id ] = {
			element: element,
			tooltip: tooltip
		};
	},

	_find: function( target ) {
		var id = target.data( &quot;ui-tooltip-id&quot; );
		return id ? this.tooltips[ id ] : null;
	},

	_removeTooltip: function( tooltip ) {

		// Clear the interval for delayed tracking tooltips
		clearInterval( this.delayedShow );

		tooltip.remove();
		delete this.tooltips[ tooltip.attr( &quot;id&quot; ) ];
	},

	_appendTo: function( target ) {
		var element = target.closest( &quot;.ui-front, dialog&quot; );

		if ( !element.length ) {
			element = this.document[ 0 ].body;
		}

		return element;
	},

	_destroy: function() {
		var that = this;

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

			// Delegate to close method to handle common cleanup
			var event = $.Event( &quot;blur&quot; ),
				element = tooltipData.element;
			event.target = event.currentTarget = element[ 0 ];
			that.close( event, true );

			// Remove immediately; destroying an open tooltip doesn&#039;t use the
			// hide animation
			$( &quot;#&quot; + id ).remove();

			// Restore the title
			if ( element.data( &quot;ui-tooltip-title&quot; ) ) {

				// If the title attribute has changed since open(), don&#039;t restore
				if ( !element.attr( &quot;title&quot; ) ) {
					element.attr( &quot;title&quot;, element.data( &quot;ui-tooltip-title&quot; ) );
				}
				element.removeData( &quot;ui-tooltip-title&quot; );
			}
		} );
		this.liveRegion.remove();
	}
} );

// DEPRECATED
// TODO: Switch return back to widget declaration at top of file when this is removed
if ( $.uiBackCompat !== false ) {

	// Backcompat for tooltipClass option
	$.widget( &quot;ui.tooltip&quot;, $.ui.tooltip, {
		options: {
			tooltipClass: null
		},
		_tooltip: function() {
			var tooltipData = this._superApply( arguments );
			if ( this.options.tooltipClass ) {
				tooltipData.tooltip.addClass( this.options.tooltipClass );
			}
			return tooltipData;
		}
	} );
}

return $.ui.tooltip;

} );
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Fjs%2Fjquery'>?? Yukar?</a>