/*!

 * jQuery UI Autocomplete 1.13.3

 * https://jqueryui.com

 *

 * Copyright OpenJS Foundation and other contributors

 * Released under the MIT license.

 * https://jquery.org/license

 */

//>>label: Autocomplete

//>>group: Widgets

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

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

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

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

//>>css.structure: ../../themes/base/autocomplete.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",

			"./menu",

			"../keycode",

			"../position",

			"../safe-active-element",

			"../version",

			"../widget"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

$.widget( "ui.autocomplete", {

	version: "1.13.3",

	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,

	liveRegionTimer: null,

	_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 ) {

				case keyCode.PAGE_UP:

					suppressKeyPress = true;

					this._move( "previousPage", event );

					break;

				case keyCode.PAGE_DOWN:

					suppressKeyPress = true;

					this._move( "nextPage", event );

					break;

				case keyCode.UP:

					suppressKeyPress = true;

					this._keyEvent( "previous", event );

					break;

				case keyCode.DOWN:

					suppressKeyPress = true;

					this._keyEvent( "next", event );

					break;

				case keyCode.ENTER:

					// when menu is open and has focus

					if ( this.menu.active ) {

						// #6055 - Opera still allows the keypress to occur

						// which causes forms to submit

						suppressKeyPress = true;

						event.preventDefault();

						this.menu.select( event );

					}

					break;

				case keyCode.TAB:

					if ( this.menu.active ) {

						this.menu.select( event );

					}

					break;

				case keyCode.ESCAPE:

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

						if ( !this.isMultiLine ) {

							this._value( this.term );

						}

						this.close( event );

						// Different browsers have different default behavior for escape

						// Single press can mean undo or clear

						// Double press in IE means clear the whole form

						event.preventDefault();

					}

					break;

				default:

					suppressKeyPressRepeat = true;

					// search timeout should be triggered before the input value is changed

					this._searchTimeout( event );

					break;

				}

			},

			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 ) {

				case keyCode.PAGE_UP:

					this._move( "previousPage", event );

					break;

				case keyCode.PAGE_DOWN:

					this._move( "nextPage", event );

					break;

				case keyCode.UP:

					this._keyEvent( "previous", event );

					break;

				case keyCode.DOWN:

					this._keyEvent( "next", event );

					break;

				}

			},

			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()

			// Support: IE 11 only, Edge <= 14

			// For other browsers, we preventDefault() on the mousedown event

			// to keep the dropdown from taking focus from the input. This doesn't

			// work for IE/Edge, causing problems with selection and scrolling (#9638)

			// Happily, IE and Edge support an "unselectable" attribute that

			// prevents an element from receiving focus, exactly what we want here.

			.attr( {

				"unselectable": "on"

			} )

			.menu( "instance" );

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

		this._on( this.menu.element, {

			mousedown: function( event ) {

				// Prevent moving focus out of the text field

				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;

				if ( label && String.prototype.trim.call( label ).length ) {

					clearTimeout( this.liveRegionTimer );

					this.liveRegionTimer = this._delay( function() {

						this.liveRegion.html( $( "<div>" ).text( label ) );

					}, 100 );

				}

			},

			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 ) :