/*!

 * http://jqueryui.com

 *

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 */

//>>label: Autocomplete

//>>group: Widgets

//>>description: Lists suggested words as the user is typing.

//>>docs: http://api.jqueryui.com/autocomplete/

//>>demos: http://jqueryui.com/autocomplete/

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

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

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

( function( factory ) {

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

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./menu",

			"./core"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

$.widget( "ui.autocomplete", {

	defaultElement: "<input>",

	options: {

		appendTo: null,

		autoFocus: false,

		delay: 300,

		minLength: 1,

		position: {

			my: "left top",

			at: "left bottom",

			collision: "none"

		},

		source: null,

		// Callbacks

		change: null,

		close: null,

		focus: null,

		open: null,

		response: null,

		search: null,

		select: null

	},

	requestIndex: 0,

	pending: 0,

	_create: function() {

		// Some browsers only repeat keydown events, not keypress events,

		// so we use the suppressKeyPress flag to determine if we've already

		// handled the keydown event. #7269

		// Unfortunately the code for & in keypress is the same as the up arrow,

		// so we use the suppressKeyPressRepeat flag to avoid handling keypress

		// events when we know the keydown event was used to modify the

		// search term. #7799

		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,

			nodeName = this.element[ 0 ].nodeName.toLowerCase(),

			isTextarea = nodeName === "textarea",

			isInput = nodeName === "input";

		// Textareas are always multi-line

		// Inputs are always single-line, even if inside a contentEditable element

		// IE also treats inputs as contentEditable

		// All other element types are determined by whether or not they're contentEditable

		this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );

		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];

		this.isNewMenu = true;

		this._addClass( "ui-autocomplete-input" );

		this.element.attr( "autocomplete", "off" );

		this._on( this.element, {

			keydown: function( event ) {

				if ( this.element.prop( "readOnly" ) ) {

					suppressKeyPress = true;

					suppressInput = true;

					suppressKeyPressRepeat = true;

					return;

				}

				suppressKeyPress = false;

				suppressInput = false;

				suppressKeyPressRepeat = false;

				var keyCode = $.ui.keyCode;

				switch ( event.keyCode ) {

						suppressKeyPress = true;

						}

				}

			},

			keypress: function( event ) {

				if ( suppressKeyPress ) {

					suppressKeyPress = false;

					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {

						event.preventDefault();

					}

					return;

				}

				if ( suppressKeyPressRepeat ) {

					return;

				}

				// Replicate some key handlers to allow them to repeat in Firefox and Opera

				var keyCode = $.ui.keyCode;

				switch ( event.keyCode ) {

				}

			},

			input: function( event ) {

				if ( suppressInput ) {

					suppressInput = false;

					event.preventDefault();

					return;

				}

				this._searchTimeout( event );

			},

			focus: function() {

				this.selectedItem = null;

				this.previous = this._value();

			},

			blur: function( event ) {

				clearTimeout( this.searching );

				this.close( event );

				this._change( event );

			}

		} );

		this._initSource();

		this.menu = $( "<ul>" )

			.appendTo( this._appendTo() )

			.menu( {

				// disable ARIA support, the live region takes care of that

				role: null

			} )

			.hide()

			.menu( "instance" );

		this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );

		this._on( this.menu.element, {

			mousedown: function( event ) {

				event.preventDefault();

			},

			menufocus: function( event, ui ) {

				var label, item;

				// support: Firefox

				// Prevent accidental activation of menu items in Firefox (#7024 #9118)

				if ( this.isNewMenu ) {

					this.isNewMenu = false;

					if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {

						this.menu.blur();

						this.document.one( "mousemove", function() {

							$( event.target ).trigger( event.originalEvent );

						} );

						return;

					}

				}

				item = ui.item.data( "ui-autocomplete-item" );

				if ( false !== this._trigger( "focus", event, { item: item } ) ) {

					// use value to match what will end up in the input, if it was a key event

					if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {

						this._value( item.value );

					}

				}

				// Announce the value in the liveRegion

				label = ui.item.attr( "aria-label" ) || item.value;

				}

			},

			menuselect: function( event, ui ) {

				var item = ui.item.data( "ui-autocomplete-item" ),

					previous = this.previous;

				// Only trigger when focus was lost (click on menu)

				if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {

					this.element.trigger( "focus" );

					this.previous = previous;

					// #6109 - IE triggers two focus events and the second

					// is asynchronous, so we need to reset the previous

					// term synchronously and asynchronously :-(

					this._delay( function() {

						this.previous = previous;

						this.selectedItem = item;

					} );

				}

				if ( false !== this._trigger( "select", event, { item: item } ) ) {

					this._value( item.value );

				}

				// reset the term after the select event

				// this allows custom select handling to work properly

				this.term = this._value();

				this.close( event );

				this.selectedItem = item;

			}

		} );

		this.liveRegion = $( "<div>", {

			role: "status",

			"aria-live": "assertive",

			"aria-relevant": "additions"

		} )

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

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

		// Turning off autocomplete prevents the browser from remembering the

		// value when navigating through history, so we re-enable autocomplete

		// if the page is unloaded before the widget is destroyed. #7790

		this._on( this.window, {

			beforeunload: function() {

				this.element.removeAttr( "autocomplete" );

			}

		} );

	},

	_destroy: function() {

		clearTimeout( this.searching );

		this.element.removeAttr( "autocomplete" );

		this.menu.element.remove();

		this.liveRegion.remove();

	},

	_setOption: function( key, value ) {

		this._super( key, value );

		if ( key === "source" ) {

			this._initSource();

		}

		if ( key === "appendTo" ) {

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

		}

		if ( key === "disabled" && value && this.xhr ) {

			this.xhr.abort();

		}

	},

	_isEventTargetInWidget: function( event ) {

		var menuElement = this.menu.element[ 0 ];

		return event.target === this.element[ 0 ] ||

			event.target === menuElement ||

			$.contains( menuElement, event.target );

	},

	_closeOnClickOutside: function( event ) {

		if ( !this._isEventTargetInWidget( event ) ) {

			this.close();

		}

	},

	_appendTo: function() {

		var element = this.options.appendTo;

		if ( element ) {

			element = element.jquery || element.nodeType ?

				$( element ) :

				this.document.find( element ).eq( 0 );

		}

		if ( !element || !element[ 0 ] ) {