fix
[wolnelektury.git] / src / wolnelektury / static / contrib / jquery-ui-1.13.1.custom / jquery-ui.js
1 /*! jQuery UI - v1.13.1 - 2022-02-02
2 * http://jqueryui.com
3 * Includes: widget.js, position.js, keycode.js, unique-id.js, widgets/autocomplete.js, widgets/menu.js
4 * Copyright jQuery Foundation and other contributors; Licensed MIT */
5
6 ( function( factory ) {
7         "use strict";
8         
9         if ( typeof define === "function" && define.amd ) {
10
11                 // AMD. Register as an anonymous module.
12                 define( [ "jquery" ], factory );
13         } else {
14
15                 // Browser globals
16                 factory( jQuery );
17         }
18 } )( function( $ ) {
19 "use strict";
20
21 $.ui = $.ui || {};
22
23 var version = $.ui.version = "1.13.1";
24
25
26 /*!
27  * jQuery UI Widget 1.13.1
28  * http://jqueryui.com
29  *
30  * Copyright jQuery Foundation and other contributors
31  * Released under the MIT license.
32  * http://jquery.org/license
33  */
34
35 //>>label: Widget
36 //>>group: Core
37 //>>description: Provides a factory for creating stateful widgets with a common API.
38 //>>docs: http://api.jqueryui.com/jQuery.widget/
39 //>>demos: http://jqueryui.com/widget/
40
41
42 var widgetUuid = 0;
43 var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
44 var widgetSlice = Array.prototype.slice;
45
46 $.cleanData = ( function( orig ) {
47         return function( elems ) {
48                 var events, elem, i;
49                 for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
50
51                         // Only trigger remove when necessary to save time
52                         events = $._data( elem, "events" );
53                         if ( events && events.remove ) {
54                                 $( elem ).triggerHandler( "remove" );
55                         }
56                 }
57                 orig( elems );
58         };
59 } )( $.cleanData );
60
61 $.widget = function( name, base, prototype ) {
62         var existingConstructor, constructor, basePrototype;
63
64         // ProxiedPrototype allows the provided prototype to remain unmodified
65         // so that it can be used as a mixin for multiple widgets (#8876)
66         var proxiedPrototype = {};
67
68         var namespace = name.split( "." )[ 0 ];
69         name = name.split( "." )[ 1 ];
70         var fullName = namespace + "-" + name;
71
72         if ( !prototype ) {
73                 prototype = base;
74                 base = $.Widget;
75         }
76
77         if ( Array.isArray( prototype ) ) {
78                 prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
79         }
80
81         // Create selector for plugin
82         $.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) {
83                 return !!$.data( elem, fullName );
84         };
85
86         $[ namespace ] = $[ namespace ] || {};
87         existingConstructor = $[ namespace ][ name ];
88         constructor = $[ namespace ][ name ] = function( options, element ) {
89
90                 // Allow instantiation without "new" keyword
91                 if ( !this || !this._createWidget ) {
92                         return new constructor( options, element );
93                 }
94
95                 // Allow instantiation without initializing for simple inheritance
96                 // must use "new" keyword (the code above always passes args)
97                 if ( arguments.length ) {
98                         this._createWidget( options, element );
99                 }
100         };
101
102         // Extend with the existing constructor to carry over any static properties
103         $.extend( constructor, existingConstructor, {
104                 version: prototype.version,
105
106                 // Copy the object used to create the prototype in case we need to
107                 // redefine the widget later
108                 _proto: $.extend( {}, prototype ),
109
110                 // Track widgets that inherit from this widget in case this widget is
111                 // redefined after a widget inherits from it
112                 _childConstructors: []
113         } );
114
115         basePrototype = new base();
116
117         // We need to make the options hash a property directly on the new instance
118         // otherwise we'll modify the options hash on the prototype that we're
119         // inheriting from
120         basePrototype.options = $.widget.extend( {}, basePrototype.options );
121         $.each( prototype, function( prop, value ) {
122                 if ( typeof value !== "function" ) {
123                         proxiedPrototype[ prop ] = value;
124                         return;
125                 }
126                 proxiedPrototype[ prop ] = ( function() {
127                         function _super() {
128                                 return base.prototype[ prop ].apply( this, arguments );
129                         }
130
131                         function _superApply( args ) {
132                                 return base.prototype[ prop ].apply( this, args );
133                         }
134
135                         return function() {
136                                 var __super = this._super;
137                                 var __superApply = this._superApply;
138                                 var returnValue;
139
140                                 this._super = _super;
141                                 this._superApply = _superApply;
142
143                                 returnValue = value.apply( this, arguments );
144
145                                 this._super = __super;
146                                 this._superApply = __superApply;
147
148                                 return returnValue;
149                         };
150                 } )();
151         } );
152         constructor.prototype = $.widget.extend( basePrototype, {
153
154                 // TODO: remove support for widgetEventPrefix
155                 // always use the name + a colon as the prefix, e.g., draggable:start
156                 // don't prefix for widgets that aren't DOM-based
157                 widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
158         }, proxiedPrototype, {
159                 constructor: constructor,
160                 namespace: namespace,
161                 widgetName: name,
162                 widgetFullName: fullName
163         } );
164
165         // If this widget is being redefined then we need to find all widgets that
166         // are inheriting from it and redefine all of them so that they inherit from
167         // the new version of this widget. We're essentially trying to replace one
168         // level in the prototype chain.
169         if ( existingConstructor ) {
170                 $.each( existingConstructor._childConstructors, function( i, child ) {
171                         var childPrototype = child.prototype;
172
173                         // Redefine the child widget using the same prototype that was
174                         // originally used, but inherit from the new version of the base
175                         $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
176                                 child._proto );
177                 } );
178
179                 // Remove the list of existing child constructors from the old constructor
180                 // so the old child constructors can be garbage collected
181                 delete existingConstructor._childConstructors;
182         } else {
183                 base._childConstructors.push( constructor );
184         }
185
186         $.widget.bridge( name, constructor );
187
188         return constructor;
189 };
190
191 $.widget.extend = function( target ) {
192         var input = widgetSlice.call( arguments, 1 );
193         var inputIndex = 0;
194         var inputLength = input.length;
195         var key;
196         var value;
197
198         for ( ; inputIndex < inputLength; inputIndex++ ) {
199                 for ( key in input[ inputIndex ] ) {
200                         value = input[ inputIndex ][ key ];
201                         if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) {
202
203                                 // Clone objects
204                                 if ( $.isPlainObject( value ) ) {
205                                         target[ key ] = $.isPlainObject( target[ key ] ) ?
206                                                 $.widget.extend( {}, target[ key ], value ) :
207
208                                                 // Don't extend strings, arrays, etc. with objects
209                                                 $.widget.extend( {}, value );
210
211                                 // Copy everything else by reference
212                                 } else {
213                                         target[ key ] = value;
214                                 }
215                         }
216                 }
217         }
218         return target;
219 };
220
221 $.widget.bridge = function( name, object ) {
222         var fullName = object.prototype.widgetFullName || name;
223         $.fn[ name ] = function( options ) {
224                 var isMethodCall = typeof options === "string";
225                 var args = widgetSlice.call( arguments, 1 );
226                 var returnValue = this;
227
228                 if ( isMethodCall ) {
229
230                         // If this is an empty collection, we need to have the instance method
231                         // return undefined instead of the jQuery instance
232                         if ( !this.length && options === "instance" ) {
233                                 returnValue = undefined;
234                         } else {
235                                 this.each( function() {
236                                         var methodValue;
237                                         var instance = $.data( this, fullName );
238
239                                         if ( options === "instance" ) {
240                                                 returnValue = instance;
241                                                 return false;
242                                         }
243
244                                         if ( !instance ) {
245                                                 return $.error( "cannot call methods on " + name +
246                                                         " prior to initialization; " +
247                                                         "attempted to call method '" + options + "'" );
248                                         }
249
250                                         if ( typeof instance[ options ] !== "function" ||
251                                                 options.charAt( 0 ) === "_" ) {
252                                                 return $.error( "no such method '" + options + "' for " + name +
253                                                         " widget instance" );
254                                         }
255
256                                         methodValue = instance[ options ].apply( instance, args );
257
258                                         if ( methodValue !== instance && methodValue !== undefined ) {
259                                                 returnValue = methodValue && methodValue.jquery ?
260                                                         returnValue.pushStack( methodValue.get() ) :
261                                                         methodValue;
262                                                 return false;
263                                         }
264                                 } );
265                         }
266                 } else {
267
268                         // Allow multiple hashes to be passed on init
269                         if ( args.length ) {
270                                 options = $.widget.extend.apply( null, [ options ].concat( args ) );
271                         }
272
273                         this.each( function() {
274                                 var instance = $.data( this, fullName );
275                                 if ( instance ) {
276                                         instance.option( options || {} );
277                                         if ( instance._init ) {
278                                                 instance._init();
279                                         }
280                                 } else {
281                                         $.data( this, fullName, new object( options, this ) );
282                                 }
283                         } );
284                 }
285
286                 return returnValue;
287         };
288 };
289
290 $.Widget = function( /* options, element */ ) {};
291 $.Widget._childConstructors = [];
292
293 $.Widget.prototype = {
294         widgetName: "widget",
295         widgetEventPrefix: "",
296         defaultElement: "<div>",
297
298         options: {
299                 classes: {},
300                 disabled: false,
301
302                 // Callbacks
303                 create: null
304         },
305
306         _createWidget: function( options, element ) {
307                 element = $( element || this.defaultElement || this )[ 0 ];
308                 this.element = $( element );
309                 this.uuid = widgetUuid++;
310                 this.eventNamespace = "." + this.widgetName + this.uuid;
311
312                 this.bindings = $();
313                 this.hoverable = $();
314                 this.focusable = $();
315                 this.classesElementLookup = {};
316
317                 if ( element !== this ) {
318                         $.data( element, this.widgetFullName, this );
319                         this._on( true, this.element, {
320                                 remove: function( event ) {
321                                         if ( event.target === element ) {
322                                                 this.destroy();
323                                         }
324                                 }
325                         } );
326                         this.document = $( element.style ?
327
328                                 // Element within the document
329                                 element.ownerDocument :
330
331                                 // Element is window or document
332                                 element.document || element );
333                         this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
334                 }
335
336                 this.options = $.widget.extend( {},
337                         this.options,
338                         this._getCreateOptions(),
339                         options );
340
341                 this._create();
342
343                 if ( this.options.disabled ) {
344                         this._setOptionDisabled( this.options.disabled );
345                 }
346
347                 this._trigger( "create", null, this._getCreateEventData() );
348                 this._init();
349         },
350
351         _getCreateOptions: function() {
352                 return {};
353         },
354
355         _getCreateEventData: $.noop,
356
357         _create: $.noop,
358
359         _init: $.noop,
360
361         destroy: function() {
362                 var that = this;
363
364                 this._destroy();
365                 $.each( this.classesElementLookup, function( key, value ) {
366                         that._removeClass( value, key );
367                 } );
368
369                 // We can probably remove the unbind calls in 2.0
370                 // all event bindings should go through this._on()
371                 this.element
372                         .off( this.eventNamespace )
373                         .removeData( this.widgetFullName );
374                 this.widget()
375                         .off( this.eventNamespace )
376                         .removeAttr( "aria-disabled" );
377
378                 // Clean up events and states
379                 this.bindings.off( this.eventNamespace );
380         },
381
382         _destroy: $.noop,
383
384         widget: function() {
385                 return this.element;
386         },
387
388         option: function( key, value ) {
389                 var options = key;
390                 var parts;
391                 var curOption;
392                 var i;
393
394                 if ( arguments.length === 0 ) {
395
396                         // Don't return a reference to the internal hash
397                         return $.widget.extend( {}, this.options );
398                 }
399
400                 if ( typeof key === "string" ) {
401
402                         // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
403                         options = {};
404                         parts = key.split( "." );
405                         key = parts.shift();
406                         if ( parts.length ) {
407                                 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
408                                 for ( i = 0; i < parts.length - 1; i++ ) {
409                                         curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
410                                         curOption = curOption[ parts[ i ] ];
411                                 }
412                                 key = parts.pop();
413                                 if ( arguments.length === 1 ) {
414                                         return curOption[ key ] === undefined ? null : curOption[ key ];
415                                 }
416                                 curOption[ key ] = value;
417                         } else {
418                                 if ( arguments.length === 1 ) {
419                                         return this.options[ key ] === undefined ? null : this.options[ key ];
420                                 }
421                                 options[ key ] = value;
422                         }
423                 }
424
425                 this._setOptions( options );
426
427                 return this;
428         },
429
430         _setOptions: function( options ) {
431                 var key;
432
433                 for ( key in options ) {
434                         this._setOption( key, options[ key ] );
435                 }
436
437                 return this;
438         },
439
440         _setOption: function( key, value ) {
441                 if ( key === "classes" ) {
442                         this._setOptionClasses( value );
443                 }
444
445                 this.options[ key ] = value;
446
447                 if ( key === "disabled" ) {
448                         this._setOptionDisabled( value );
449                 }
450
451                 return this;
452         },
453
454         _setOptionClasses: function( value ) {
455                 var classKey, elements, currentElements;
456
457                 for ( classKey in value ) {
458                         currentElements = this.classesElementLookup[ classKey ];
459                         if ( value[ classKey ] === this.options.classes[ classKey ] ||
460                                         !currentElements ||
461                                         !currentElements.length ) {
462                                 continue;
463                         }
464
465                         // We are doing this to create a new jQuery object because the _removeClass() call
466                         // on the next line is going to destroy the reference to the current elements being
467                         // tracked. We need to save a copy of this collection so that we can add the new classes
468                         // below.
469                         elements = $( currentElements.get() );
470                         this._removeClass( currentElements, classKey );
471
472                         // We don't use _addClass() here, because that uses this.options.classes
473                         // for generating the string of classes. We want to use the value passed in from
474                         // _setOption(), this is the new value of the classes option which was passed to
475                         // _setOption(). We pass this value directly to _classes().
476                         elements.addClass( this._classes( {
477                                 element: elements,
478                                 keys: classKey,
479                                 classes: value,
480                                 add: true
481                         } ) );
482                 }
483         },
484
485         _setOptionDisabled: function( value ) {
486                 this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
487
488                 // If the widget is becoming disabled, then nothing is interactive
489                 if ( value ) {
490                         this._removeClass( this.hoverable, null, "ui-state-hover" );
491                         this._removeClass( this.focusable, null, "ui-state-focus" );
492                 }
493         },
494
495         enable: function() {
496                 return this._setOptions( { disabled: false } );
497         },
498
499         disable: function() {
500                 return this._setOptions( { disabled: true } );
501         },
502
503         _classes: function( options ) {
504                 var full = [];
505                 var that = this;
506
507                 options = $.extend( {
508                         element: this.element,
509                         classes: this.options.classes || {}
510                 }, options );
511
512                 function bindRemoveEvent() {
513                         var nodesToBind = [];
514
515                         options.element.each( function( _, element ) {
516                                 var isTracked = $.map( that.classesElementLookup, function( elements ) {
517                                         return elements;
518                                 } )
519                                         .some( function( elements ) {
520                                                 return elements.is( element );
521                                         } );
522
523                                 if ( !isTracked ) {
524                                         nodesToBind.push( element );
525                                 }
526                         } );
527
528                         that._on( $( nodesToBind ), {
529                                 remove: "_untrackClassesElement"
530                         } );
531                 }
532
533                 function processClassString( classes, checkOption ) {
534                         var current, i;
535                         for ( i = 0; i < classes.length; i++ ) {
536                                 current = that.classesElementLookup[ classes[ i ] ] || $();
537                                 if ( options.add ) {
538                                         bindRemoveEvent();
539                                         current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
540                                 } else {
541                                         current = $( current.not( options.element ).get() );
542                                 }
543                                 that.classesElementLookup[ classes[ i ] ] = current;
544                                 full.push( classes[ i ] );
545                                 if ( checkOption && options.classes[ classes[ i ] ] ) {
546                                         full.push( options.classes[ classes[ i ] ] );
547                                 }
548                         }
549                 }
550
551                 if ( options.keys ) {
552                         processClassString( options.keys.match( /\S+/g ) || [], true );
553                 }
554                 if ( options.extra ) {
555                         processClassString( options.extra.match( /\S+/g ) || [] );
556                 }
557
558                 return full.join( " " );
559         },
560
561         _untrackClassesElement: function( event ) {
562                 var that = this;
563                 $.each( that.classesElementLookup, function( key, value ) {
564                         if ( $.inArray( event.target, value ) !== -1 ) {
565                                 that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
566                         }
567                 } );
568
569                 this._off( $( event.target ) );
570         },
571
572         _removeClass: function( element, keys, extra ) {
573                 return this._toggleClass( element, keys, extra, false );
574         },
575
576         _addClass: function( element, keys, extra ) {
577                 return this._toggleClass( element, keys, extra, true );
578         },
579
580         _toggleClass: function( element, keys, extra, add ) {
581                 add = ( typeof add === "boolean" ) ? add : extra;
582                 var shift = ( typeof element === "string" || element === null ),
583                         options = {
584                                 extra: shift ? keys : extra,
585                                 keys: shift ? element : keys,
586                                 element: shift ? this.element : element,
587                                 add: add
588                         };
589                 options.element.toggleClass( this._classes( options ), add );
590                 return this;
591         },
592
593         _on: function( suppressDisabledCheck, element, handlers ) {
594                 var delegateElement;
595                 var instance = this;
596
597                 // No suppressDisabledCheck flag, shuffle arguments
598                 if ( typeof suppressDisabledCheck !== "boolean" ) {
599                         handlers = element;
600                         element = suppressDisabledCheck;
601                         suppressDisabledCheck = false;
602                 }
603
604                 // No element argument, shuffle and use this.element
605                 if ( !handlers ) {
606                         handlers = element;
607                         element = this.element;
608                         delegateElement = this.widget();
609                 } else {
610                         element = delegateElement = $( element );
611                         this.bindings = this.bindings.add( element );
612                 }
613
614                 $.each( handlers, function( event, handler ) {
615                         function handlerProxy() {
616
617                                 // Allow widgets to customize the disabled handling
618                                 // - disabled as an array instead of boolean
619                                 // - disabled class as method for disabling individual parts
620                                 if ( !suppressDisabledCheck &&
621                                                 ( instance.options.disabled === true ||
622                                                 $( this ).hasClass( "ui-state-disabled" ) ) ) {
623                                         return;
624                                 }
625                                 return ( typeof handler === "string" ? instance[ handler ] : handler )
626                                         .apply( instance, arguments );
627                         }
628
629                         // Copy the guid so direct unbinding works
630                         if ( typeof handler !== "string" ) {
631                                 handlerProxy.guid = handler.guid =
632                                         handler.guid || handlerProxy.guid || $.guid++;
633                         }
634
635                         var match = event.match( /^([\w:-]*)\s*(.*)$/ );
636                         var eventName = match[ 1 ] + instance.eventNamespace;
637                         var selector = match[ 2 ];
638
639                         if ( selector ) {
640                                 delegateElement.on( eventName, selector, handlerProxy );
641                         } else {
642                                 element.on( eventName, handlerProxy );
643                         }
644                 } );
645         },
646
647         _off: function( element, eventName ) {
648                 eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
649                         this.eventNamespace;
650                 element.off( eventName );
651
652                 // Clear the stack to avoid memory leaks (#10056)
653                 this.bindings = $( this.bindings.not( element ).get() );
654                 this.focusable = $( this.focusable.not( element ).get() );
655                 this.hoverable = $( this.hoverable.not( element ).get() );
656         },
657
658         _delay: function( handler, delay ) {
659                 function handlerProxy() {
660                         return ( typeof handler === "string" ? instance[ handler ] : handler )
661                                 .apply( instance, arguments );
662                 }
663                 var instance = this;
664                 return setTimeout( handlerProxy, delay || 0 );
665         },
666
667         _hoverable: function( element ) {
668                 this.hoverable = this.hoverable.add( element );
669                 this._on( element, {
670                         mouseenter: function( event ) {
671                                 this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
672                         },
673                         mouseleave: function( event ) {
674                                 this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
675                         }
676                 } );
677         },
678
679         _focusable: function( element ) {
680                 this.focusable = this.focusable.add( element );
681                 this._on( element, {
682                         focusin: function( event ) {
683                                 this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
684                         },
685                         focusout: function( event ) {
686                                 this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
687                         }
688                 } );
689         },
690
691         _trigger: function( type, event, data ) {
692                 var prop, orig;
693                 var callback = this.options[ type ];
694
695                 data = data || {};
696                 event = $.Event( event );
697                 event.type = ( type === this.widgetEventPrefix ?
698                         type :
699                         this.widgetEventPrefix + type ).toLowerCase();
700
701                 // The original event may come from any element
702                 // so we need to reset the target on the new event
703                 event.target = this.element[ 0 ];
704
705                 // Copy original event properties over to the new event
706                 orig = event.originalEvent;
707                 if ( orig ) {
708                         for ( prop in orig ) {
709                                 if ( !( prop in event ) ) {
710                                         event[ prop ] = orig[ prop ];
711                                 }
712                         }
713                 }
714
715                 this.element.trigger( event, data );
716                 return !( typeof callback === "function" &&
717                         callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
718                         event.isDefaultPrevented() );
719         }
720 };
721
722 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
723         $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
724                 if ( typeof options === "string" ) {
725                         options = { effect: options };
726                 }
727
728                 var hasOptions;
729                 var effectName = !options ?
730                         method :
731                         options === true || typeof options === "number" ?
732                                 defaultEffect :
733                                 options.effect || defaultEffect;
734
735                 options = options || {};
736                 if ( typeof options === "number" ) {
737                         options = { duration: options };
738                 } else if ( options === true ) {
739                         options = {};
740                 }
741
742                 hasOptions = !$.isEmptyObject( options );
743                 options.complete = callback;
744
745                 if ( options.delay ) {
746                         element.delay( options.delay );
747                 }
748
749                 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
750                         element[ method ]( options );
751                 } else if ( effectName !== method && element[ effectName ] ) {
752                         element[ effectName ]( options.duration, options.easing, callback );
753                 } else {
754                         element.queue( function( next ) {
755                                 $( this )[ method ]();
756                                 if ( callback ) {
757                                         callback.call( element[ 0 ] );
758                                 }
759                                 next();
760                         } );
761                 }
762         };
763 } );
764
765 var widget = $.widget;
766
767
768 /*!
769  * jQuery UI Position 1.13.1
770  * http://jqueryui.com
771  *
772  * Copyright jQuery Foundation and other contributors
773  * Released under the MIT license.
774  * http://jquery.org/license
775  *
776  * http://api.jqueryui.com/position/
777  */
778
779 //>>label: Position
780 //>>group: Core
781 //>>description: Positions elements relative to other elements.
782 //>>docs: http://api.jqueryui.com/position/
783 //>>demos: http://jqueryui.com/position/
784
785
786 ( function() {
787 var cachedScrollbarWidth,
788         max = Math.max,
789         abs = Math.abs,
790         rhorizontal = /left|center|right/,
791         rvertical = /top|center|bottom/,
792         roffset = /[\+\-]\d+(\.[\d]+)?%?/,
793         rposition = /^\w+/,
794         rpercent = /%$/,
795         _position = $.fn.position;
796
797 function getOffsets( offsets, width, height ) {
798         return [
799                 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
800                 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
801         ];
802 }
803
804 function parseCss( element, property ) {
805         return parseInt( $.css( element, property ), 10 ) || 0;
806 }
807
808 function isWindow( obj ) {
809         return obj != null && obj === obj.window;
810 }
811
812 function getDimensions( elem ) {
813         var raw = elem[ 0 ];
814         if ( raw.nodeType === 9 ) {
815                 return {
816                         width: elem.width(),
817                         height: elem.height(),
818                         offset: { top: 0, left: 0 }
819                 };
820         }
821         if ( isWindow( raw ) ) {
822                 return {
823                         width: elem.width(),
824                         height: elem.height(),
825                         offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
826                 };
827         }
828         if ( raw.preventDefault ) {
829                 return {
830                         width: 0,
831                         height: 0,
832                         offset: { top: raw.pageY, left: raw.pageX }
833                 };
834         }
835         return {
836                 width: elem.outerWidth(),
837                 height: elem.outerHeight(),
838                 offset: elem.offset()
839         };
840 }
841
842 $.position = {
843         scrollbarWidth: function() {
844                 if ( cachedScrollbarWidth !== undefined ) {
845                         return cachedScrollbarWidth;
846                 }
847                 var w1, w2,
848                         div = $( "<div style=" +
849                                 "'display:block;position:absolute;width:200px;height:200px;overflow:hidden;'>" +
850                                 "<div style='height:300px;width:auto;'></div></div>" ),
851                         innerDiv = div.children()[ 0 ];
852
853                 $( "body" ).append( div );
854                 w1 = innerDiv.offsetWidth;
855                 div.css( "overflow", "scroll" );
856
857                 w2 = innerDiv.offsetWidth;
858
859                 if ( w1 === w2 ) {
860                         w2 = div[ 0 ].clientWidth;
861                 }
862
863                 div.remove();
864
865                 return ( cachedScrollbarWidth = w1 - w2 );
866         },
867         getScrollInfo: function( within ) {
868                 var overflowX = within.isWindow || within.isDocument ? "" :
869                                 within.element.css( "overflow-x" ),
870                         overflowY = within.isWindow || within.isDocument ? "" :
871                                 within.element.css( "overflow-y" ),
872                         hasOverflowX = overflowX === "scroll" ||
873                                 ( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
874                         hasOverflowY = overflowY === "scroll" ||
875                                 ( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
876                 return {
877                         width: hasOverflowY ? $.position.scrollbarWidth() : 0,
878                         height: hasOverflowX ? $.position.scrollbarWidth() : 0
879                 };
880         },
881         getWithinInfo: function( element ) {
882                 var withinElement = $( element || window ),
883                         isElemWindow = isWindow( withinElement[ 0 ] ),
884                         isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
885                         hasOffset = !isElemWindow && !isDocument;
886                 return {
887                         element: withinElement,
888                         isWindow: isElemWindow,
889                         isDocument: isDocument,
890                         offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
891                         scrollLeft: withinElement.scrollLeft(),
892                         scrollTop: withinElement.scrollTop(),
893                         width: withinElement.outerWidth(),
894                         height: withinElement.outerHeight()
895                 };
896         }
897 };
898
899 $.fn.position = function( options ) {
900         if ( !options || !options.of ) {
901                 return _position.apply( this, arguments );
902         }
903
904         // Make a copy, we don't want to modify arguments
905         options = $.extend( {}, options );
906
907         var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
908
909                 // Make sure string options are treated as CSS selectors
910                 target = typeof options.of === "string" ?
911                         $( document ).find( options.of ) :
912                         $( options.of ),
913
914                 within = $.position.getWithinInfo( options.within ),
915                 scrollInfo = $.position.getScrollInfo( within ),
916                 collision = ( options.collision || "flip" ).split( " " ),
917                 offsets = {};
918
919         dimensions = getDimensions( target );
920         if ( target[ 0 ].preventDefault ) {
921
922                 // Force left top to allow flipping
923                 options.at = "left top";
924         }
925         targetWidth = dimensions.width;
926         targetHeight = dimensions.height;
927         targetOffset = dimensions.offset;
928
929         // Clone to reuse original targetOffset later
930         basePosition = $.extend( {}, targetOffset );
931
932         // Force my and at to have valid horizontal and vertical positions
933         // if a value is missing or invalid, it will be converted to center
934         $.each( [ "my", "at" ], function() {
935                 var pos = ( options[ this ] || "" ).split( " " ),
936                         horizontalOffset,
937                         verticalOffset;
938
939                 if ( pos.length === 1 ) {
940                         pos = rhorizontal.test( pos[ 0 ] ) ?
941                                 pos.concat( [ "center" ] ) :
942                                 rvertical.test( pos[ 0 ] ) ?
943                                         [ "center" ].concat( pos ) :
944                                         [ "center", "center" ];
945                 }
946                 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
947                 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
948
949                 // Calculate offsets
950                 horizontalOffset = roffset.exec( pos[ 0 ] );
951                 verticalOffset = roffset.exec( pos[ 1 ] );
952                 offsets[ this ] = [
953                         horizontalOffset ? horizontalOffset[ 0 ] : 0,
954                         verticalOffset ? verticalOffset[ 0 ] : 0
955                 ];
956
957                 // Reduce to just the positions without the offsets
958                 options[ this ] = [
959                         rposition.exec( pos[ 0 ] )[ 0 ],
960                         rposition.exec( pos[ 1 ] )[ 0 ]
961                 ];
962         } );
963
964         // Normalize collision option
965         if ( collision.length === 1 ) {
966                 collision[ 1 ] = collision[ 0 ];
967         }
968
969         if ( options.at[ 0 ] === "right" ) {
970                 basePosition.left += targetWidth;
971         } else if ( options.at[ 0 ] === "center" ) {
972                 basePosition.left += targetWidth / 2;
973         }
974
975         if ( options.at[ 1 ] === "bottom" ) {
976                 basePosition.top += targetHeight;
977         } else if ( options.at[ 1 ] === "center" ) {
978                 basePosition.top += targetHeight / 2;
979         }
980
981         atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
982         basePosition.left += atOffset[ 0 ];
983         basePosition.top += atOffset[ 1 ];
984
985         return this.each( function() {
986                 var collisionPosition, using,
987                         elem = $( this ),
988                         elemWidth = elem.outerWidth(),
989                         elemHeight = elem.outerHeight(),
990                         marginLeft = parseCss( this, "marginLeft" ),
991                         marginTop = parseCss( this, "marginTop" ),
992                         collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
993                                 scrollInfo.width,
994                         collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
995                                 scrollInfo.height,
996                         position = $.extend( {}, basePosition ),
997                         myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
998
999                 if ( options.my[ 0 ] === "right" ) {
1000                         position.left -= elemWidth;
1001                 } else if ( options.my[ 0 ] === "center" ) {
1002                         position.left -= elemWidth / 2;
1003                 }
1004
1005                 if ( options.my[ 1 ] === "bottom" ) {
1006                         position.top -= elemHeight;
1007                 } else if ( options.my[ 1 ] === "center" ) {
1008                         position.top -= elemHeight / 2;
1009                 }
1010
1011                 position.left += myOffset[ 0 ];
1012                 position.top += myOffset[ 1 ];
1013
1014                 collisionPosition = {
1015                         marginLeft: marginLeft,
1016                         marginTop: marginTop
1017                 };
1018
1019                 $.each( [ "left", "top" ], function( i, dir ) {
1020                         if ( $.ui.position[ collision[ i ] ] ) {
1021                                 $.ui.position[ collision[ i ] ][ dir ]( position, {
1022                                         targetWidth: targetWidth,
1023                                         targetHeight: targetHeight,
1024                                         elemWidth: elemWidth,
1025                                         elemHeight: elemHeight,
1026                                         collisionPosition: collisionPosition,
1027                                         collisionWidth: collisionWidth,
1028                                         collisionHeight: collisionHeight,
1029                                         offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1030                                         my: options.my,
1031                                         at: options.at,
1032                                         within: within,
1033                                         elem: elem
1034                                 } );
1035                         }
1036                 } );
1037
1038                 if ( options.using ) {
1039
1040                         // Adds feedback as second argument to using callback, if present
1041                         using = function( props ) {
1042                                 var left = targetOffset.left - position.left,
1043                                         right = left + targetWidth - elemWidth,
1044                                         top = targetOffset.top - position.top,
1045                                         bottom = top + targetHeight - elemHeight,
1046                                         feedback = {
1047                                                 target: {
1048                                                         element: target,
1049                                                         left: targetOffset.left,
1050                                                         top: targetOffset.top,
1051                                                         width: targetWidth,
1052                                                         height: targetHeight
1053                                                 },
1054                                                 element: {
1055                                                         element: elem,
1056                                                         left: position.left,
1057                                                         top: position.top,
1058                                                         width: elemWidth,
1059                                                         height: elemHeight
1060                                                 },
1061                                                 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1062                                                 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1063                                         };
1064                                 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1065                                         feedback.horizontal = "center";
1066                                 }
1067                                 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1068                                         feedback.vertical = "middle";
1069                                 }
1070                                 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1071                                         feedback.important = "horizontal";
1072                                 } else {
1073                                         feedback.important = "vertical";
1074                                 }
1075                                 options.using.call( this, props, feedback );
1076                         };
1077                 }
1078
1079                 elem.offset( $.extend( position, { using: using } ) );
1080         } );
1081 };
1082
1083 $.ui.position = {
1084         fit: {
1085                 left: function( position, data ) {
1086                         var within = data.within,
1087                                 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1088                                 outerWidth = within.width,
1089                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1090                                 overLeft = withinOffset - collisionPosLeft,
1091                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1092                                 newOverRight;
1093
1094                         // Element is wider than within
1095                         if ( data.collisionWidth > outerWidth ) {
1096
1097                                 // Element is initially over the left side of within
1098                                 if ( overLeft > 0 && overRight <= 0 ) {
1099                                         newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
1100                                                 withinOffset;
1101                                         position.left += overLeft - newOverRight;
1102
1103                                 // Element is initially over right side of within
1104                                 } else if ( overRight > 0 && overLeft <= 0 ) {
1105                                         position.left = withinOffset;
1106
1107                                 // Element is initially over both left and right sides of within
1108                                 } else {
1109                                         if ( overLeft > overRight ) {
1110                                                 position.left = withinOffset + outerWidth - data.collisionWidth;
1111                                         } else {
1112                                                 position.left = withinOffset;
1113                                         }
1114                                 }
1115
1116                         // Too far left -> align with left edge
1117                         } else if ( overLeft > 0 ) {
1118                                 position.left += overLeft;
1119
1120                         // Too far right -> align with right edge
1121                         } else if ( overRight > 0 ) {
1122                                 position.left -= overRight;
1123
1124                         // Adjust based on position and margin
1125                         } else {
1126                                 position.left = max( position.left - collisionPosLeft, position.left );
1127                         }
1128                 },
1129                 top: function( position, data ) {
1130                         var within = data.within,
1131                                 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1132                                 outerHeight = data.within.height,
1133                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1134                                 overTop = withinOffset - collisionPosTop,
1135                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1136                                 newOverBottom;
1137
1138                         // Element is taller than within
1139                         if ( data.collisionHeight > outerHeight ) {
1140
1141                                 // Element is initially over the top of within
1142                                 if ( overTop > 0 && overBottom <= 0 ) {
1143                                         newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
1144                                                 withinOffset;
1145                                         position.top += overTop - newOverBottom;
1146
1147                                 // Element is initially over bottom of within
1148                                 } else if ( overBottom > 0 && overTop <= 0 ) {
1149                                         position.top = withinOffset;
1150
1151                                 // Element is initially over both top and bottom of within
1152                                 } else {
1153                                         if ( overTop > overBottom ) {
1154                                                 position.top = withinOffset + outerHeight - data.collisionHeight;
1155                                         } else {
1156                                                 position.top = withinOffset;
1157                                         }
1158                                 }
1159
1160                         // Too far up -> align with top
1161                         } else if ( overTop > 0 ) {
1162                                 position.top += overTop;
1163
1164                         // Too far down -> align with bottom edge
1165                         } else if ( overBottom > 0 ) {
1166                                 position.top -= overBottom;
1167
1168                         // Adjust based on position and margin
1169                         } else {
1170                                 position.top = max( position.top - collisionPosTop, position.top );
1171                         }
1172                 }
1173         },
1174         flip: {
1175                 left: function( position, data ) {
1176                         var within = data.within,
1177                                 withinOffset = within.offset.left + within.scrollLeft,
1178                                 outerWidth = within.width,
1179                                 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1180                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1181                                 overLeft = collisionPosLeft - offsetLeft,
1182                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1183                                 myOffset = data.my[ 0 ] === "left" ?
1184                                         -data.elemWidth :
1185                                         data.my[ 0 ] === "right" ?
1186                                                 data.elemWidth :
1187                                                 0,
1188                                 atOffset = data.at[ 0 ] === "left" ?
1189                                         data.targetWidth :
1190                                         data.at[ 0 ] === "right" ?
1191                                                 -data.targetWidth :
1192                                                 0,
1193                                 offset = -2 * data.offset[ 0 ],
1194                                 newOverRight,
1195                                 newOverLeft;
1196
1197                         if ( overLeft < 0 ) {
1198                                 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
1199                                         outerWidth - withinOffset;
1200                                 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1201                                         position.left += myOffset + atOffset + offset;
1202                                 }
1203                         } else if ( overRight > 0 ) {
1204                                 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
1205                                         atOffset + offset - offsetLeft;
1206                                 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1207                                         position.left += myOffset + atOffset + offset;
1208                                 }
1209                         }
1210                 },
1211                 top: function( position, data ) {
1212                         var within = data.within,
1213                                 withinOffset = within.offset.top + within.scrollTop,
1214                                 outerHeight = within.height,
1215                                 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1216                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1217                                 overTop = collisionPosTop - offsetTop,
1218                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1219                                 top = data.my[ 1 ] === "top",
1220                                 myOffset = top ?
1221                                         -data.elemHeight :
1222                                         data.my[ 1 ] === "bottom" ?
1223                                                 data.elemHeight :
1224                                                 0,
1225                                 atOffset = data.at[ 1 ] === "top" ?
1226                                         data.targetHeight :
1227                                         data.at[ 1 ] === "bottom" ?
1228                                                 -data.targetHeight :
1229                                                 0,
1230                                 offset = -2 * data.offset[ 1 ],
1231                                 newOverTop,
1232                                 newOverBottom;
1233                         if ( overTop < 0 ) {
1234                                 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
1235                                         outerHeight - withinOffset;
1236                                 if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1237                                         position.top += myOffset + atOffset + offset;
1238                                 }
1239                         } else if ( overBottom > 0 ) {
1240                                 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
1241                                         offset - offsetTop;
1242                                 if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1243                                         position.top += myOffset + atOffset + offset;
1244                                 }
1245                         }
1246                 }
1247         },
1248         flipfit: {
1249                 left: function() {
1250                         $.ui.position.flip.left.apply( this, arguments );
1251                         $.ui.position.fit.left.apply( this, arguments );
1252                 },
1253                 top: function() {
1254                         $.ui.position.flip.top.apply( this, arguments );
1255                         $.ui.position.fit.top.apply( this, arguments );
1256                 }
1257         }
1258 };
1259
1260 } )();
1261
1262 var position = $.ui.position;
1263
1264
1265 /*!
1266  * jQuery UI Keycode 1.13.1
1267  * http://jqueryui.com
1268  *
1269  * Copyright jQuery Foundation and other contributors
1270  * Released under the MIT license.
1271  * http://jquery.org/license
1272  */
1273
1274 //>>label: Keycode
1275 //>>group: Core
1276 //>>description: Provide keycodes as keynames
1277 //>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
1278
1279
1280 var keycode = $.ui.keyCode = {
1281         BACKSPACE: 8,
1282         COMMA: 188,
1283         DELETE: 46,
1284         DOWN: 40,
1285         END: 35,
1286         ENTER: 13,
1287         ESCAPE: 27,
1288         HOME: 36,
1289         LEFT: 37,
1290         PAGE_DOWN: 34,
1291         PAGE_UP: 33,
1292         PERIOD: 190,
1293         RIGHT: 39,
1294         SPACE: 32,
1295         TAB: 9,
1296         UP: 38
1297 };
1298
1299
1300 /*!
1301  * jQuery UI Unique ID 1.13.1
1302  * http://jqueryui.com
1303  *
1304  * Copyright jQuery Foundation and other contributors
1305  * Released under the MIT license.
1306  * http://jquery.org/license
1307  */
1308
1309 //>>label: uniqueId
1310 //>>group: Core
1311 //>>description: Functions to generate and remove uniqueId's
1312 //>>docs: http://api.jqueryui.com/uniqueId/
1313
1314
1315 var uniqueId = $.fn.extend( {
1316         uniqueId: ( function() {
1317                 var uuid = 0;
1318
1319                 return function() {
1320                         return this.each( function() {
1321                                 if ( !this.id ) {
1322                                         this.id = "ui-id-" + ( ++uuid );
1323                                 }
1324                         } );
1325                 };
1326         } )(),
1327
1328         removeUniqueId: function() {
1329                 return this.each( function() {
1330                         if ( /^ui-id-\d+$/.test( this.id ) ) {
1331                                 $( this ).removeAttr( "id" );
1332                         }
1333                 } );
1334         }
1335 } );
1336
1337
1338
1339 var safeActiveElement = $.ui.safeActiveElement = function( document ) {
1340         var activeElement;
1341
1342         // Support: IE 9 only
1343         // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
1344         try {
1345                 activeElement = document.activeElement;
1346         } catch ( error ) {
1347                 activeElement = document.body;
1348         }
1349
1350         // Support: IE 9 - 11 only
1351         // IE may return null instead of an element
1352         // Interestingly, this only seems to occur when NOT in an iframe
1353         if ( !activeElement ) {
1354                 activeElement = document.body;
1355         }
1356
1357         // Support: IE 11 only
1358         // IE11 returns a seemingly empty object in some cases when accessing
1359         // document.activeElement from an <iframe>
1360         if ( !activeElement.nodeName ) {
1361                 activeElement = document.body;
1362         }
1363
1364         return activeElement;
1365 };
1366
1367
1368 /*!
1369  * jQuery UI Menu 1.13.1
1370  * http://jqueryui.com
1371  *
1372  * Copyright jQuery Foundation and other contributors
1373  * Released under the MIT license.
1374  * http://jquery.org/license
1375  */
1376
1377 //>>label: Menu
1378 //>>group: Widgets
1379 //>>description: Creates nestable menus.
1380 //>>docs: http://api.jqueryui.com/menu/
1381 //>>demos: http://jqueryui.com/menu/
1382 //>>css.structure: ../../themes/base/core.css
1383 //>>css.structure: ../../themes/base/menu.css
1384 //>>css.theme: ../../themes/base/theme.css
1385
1386
1387 var widgetsMenu = $.widget( "ui.menu", {
1388         version: "1.13.1",
1389         defaultElement: "<ul>",
1390         delay: 300,
1391         options: {
1392                 icons: {
1393                         submenu: "ui-icon-caret-1-e"
1394                 },
1395                 items: "> *",
1396                 menus: "ul",
1397                 position: {
1398                         my: "left top",
1399                         at: "right top"
1400                 },
1401                 role: "menu",
1402
1403                 // Callbacks
1404                 blur: null,
1405                 focus: null,
1406                 select: null
1407         },
1408
1409         _create: function() {
1410                 this.activeMenu = this.element;
1411
1412                 // Flag used to prevent firing of the click handler
1413                 // as the event bubbles up through nested menus
1414                 this.mouseHandled = false;
1415                 this.lastMousePosition = { x: null, y: null };
1416                 this.element
1417                         .uniqueId()
1418                         .attr( {
1419                                 role: this.options.role,
1420                                 tabIndex: 0
1421                         } );
1422
1423                 this._addClass( "ui-menu", "ui-widget ui-widget-content" );
1424                 this._on( {
1425
1426                         // Prevent focus from sticking to links inside menu after clicking
1427                         // them (focus should always stay on UL during navigation).
1428                         "mousedown .ui-menu-item": function( event ) {
1429                                 event.preventDefault();
1430
1431                                 this._activateItem( event );
1432                         },
1433                         "click .ui-menu-item": function( event ) {
1434                                 var target = $( event.target );
1435                                 var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
1436                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
1437                                         this.select( event );
1438
1439                                         // Only set the mouseHandled flag if the event will bubble, see #9469.
1440                                         if ( !event.isPropagationStopped() ) {
1441                                                 this.mouseHandled = true;
1442                                         }
1443
1444                                         // Open submenu on click
1445                                         if ( target.has( ".ui-menu" ).length ) {
1446                                                 this.expand( event );
1447                                         } else if ( !this.element.is( ":focus" ) &&
1448                                                         active.closest( ".ui-menu" ).length ) {
1449
1450                                                 // Redirect focus to the menu
1451                                                 this.element.trigger( "focus", [ true ] );
1452
1453                                                 // If the active item is on the top level, let it stay active.
1454                                                 // Otherwise, blur the active item since it is no longer visible.
1455                                                 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
1456                                                         clearTimeout( this.timer );
1457                                                 }
1458                                         }
1459                                 }
1460                         },
1461                         "mouseenter .ui-menu-item": "_activateItem",
1462                         "mousemove .ui-menu-item": "_activateItem",
1463                         mouseleave: "collapseAll",
1464                         "mouseleave .ui-menu": "collapseAll",
1465                         focus: function( event, keepActiveItem ) {
1466
1467                                 // If there's already an active item, keep it active
1468                                 // If not, activate the first item
1469                                 var item = this.active || this._menuItems().first();
1470
1471                                 if ( !keepActiveItem ) {
1472                                         this.focus( event, item );
1473                                 }
1474                         },
1475                         blur: function( event ) {
1476                                 this._delay( function() {
1477                                         var notContained = !$.contains(
1478                                                 this.element[ 0 ],
1479                                                 $.ui.safeActiveElement( this.document[ 0 ] )
1480                                         );
1481                                         if ( notContained ) {
1482                                                 this.collapseAll( event );
1483                                         }
1484                                 } );
1485                         },
1486                         keydown: "_keydown"
1487                 } );
1488
1489                 this.refresh();
1490
1491                 // Clicks outside of a menu collapse any open menus
1492                 this._on( this.document, {
1493                         click: function( event ) {
1494                                 if ( this._closeOnDocumentClick( event ) ) {
1495                                         this.collapseAll( event, true );
1496                                 }
1497
1498                                 // Reset the mouseHandled flag
1499                                 this.mouseHandled = false;
1500                         }
1501                 } );
1502         },
1503
1504         _activateItem: function( event ) {
1505
1506                 // Ignore mouse events while typeahead is active, see #10458.
1507                 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
1508                 // is over an item in the menu
1509                 if ( this.previousFilter ) {
1510                         return;
1511                 }
1512
1513                 // If the mouse didn't actually move, but the page was scrolled, ignore the event (#9356)
1514                 if ( event.clientX === this.lastMousePosition.x &&
1515                                 event.clientY === this.lastMousePosition.y ) {
1516                         return;
1517                 }
1518
1519                 this.lastMousePosition = {
1520                         x: event.clientX,
1521                         y: event.clientY
1522                 };
1523
1524                 var actualTarget = $( event.target ).closest( ".ui-menu-item" ),
1525                         target = $( event.currentTarget );
1526
1527                 // Ignore bubbled events on parent items, see #11641
1528                 if ( actualTarget[ 0 ] !== target[ 0 ] ) {
1529                         return;
1530                 }
1531
1532                 // If the item is already active, there's nothing to do
1533                 if ( target.is( ".ui-state-active" ) ) {
1534                         return;
1535                 }
1536
1537                 // Remove ui-state-active class from siblings of the newly focused menu item
1538                 // to avoid a jump caused by adjacent elements both having a class with a border
1539                 this._removeClass( target.siblings().children( ".ui-state-active" ),
1540                         null, "ui-state-active" );
1541                 this.focus( event, target );
1542         },
1543
1544         _destroy: function() {
1545                 var items = this.element.find( ".ui-menu-item" )
1546                                 .removeAttr( "role aria-disabled" ),
1547                         submenus = items.children( ".ui-menu-item-wrapper" )
1548                                 .removeUniqueId()
1549                                 .removeAttr( "tabIndex role aria-haspopup" );
1550
1551                 // Destroy (sub)menus
1552                 this.element
1553                         .removeAttr( "aria-activedescendant" )
1554                         .find( ".ui-menu" ).addBack()
1555                                 .removeAttr( "role aria-labelledby aria-expanded aria-hidden aria-disabled " +
1556                                         "tabIndex" )
1557                                 .removeUniqueId()
1558                                 .show();
1559
1560                 submenus.children().each( function() {
1561                         var elem = $( this );
1562                         if ( elem.data( "ui-menu-submenu-caret" ) ) {
1563                                 elem.remove();
1564                         }
1565                 } );
1566         },
1567
1568         _keydown: function( event ) {
1569                 var match, prev, character, skip,
1570                         preventDefault = true;
1571
1572                 switch ( event.keyCode ) {
1573                 case $.ui.keyCode.PAGE_UP:
1574                         this.previousPage( event );
1575                         break;
1576                 case $.ui.keyCode.PAGE_DOWN:
1577                         this.nextPage( event );
1578                         break;
1579                 case $.ui.keyCode.HOME:
1580                         this._move( "first", "first", event );
1581                         break;
1582                 case $.ui.keyCode.END:
1583                         this._move( "last", "last", event );
1584                         break;
1585                 case $.ui.keyCode.UP:
1586                         this.previous( event );
1587                         break;
1588                 case $.ui.keyCode.DOWN:
1589                         this.next( event );
1590                         break;
1591                 case $.ui.keyCode.LEFT:
1592                         this.collapse( event );
1593                         break;
1594                 case $.ui.keyCode.RIGHT:
1595                         if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
1596                                 this.expand( event );
1597                         }
1598                         break;
1599                 case $.ui.keyCode.ENTER:
1600                 case $.ui.keyCode.SPACE:
1601                         this._activate( event );
1602                         break;
1603                 case $.ui.keyCode.ESCAPE:
1604                         this.collapse( event );
1605                         break;
1606                 default:
1607                         preventDefault = false;
1608                         prev = this.previousFilter || "";
1609                         skip = false;
1610
1611                         // Support number pad values
1612                         character = event.keyCode >= 96 && event.keyCode <= 105 ?
1613                                 ( event.keyCode - 96 ).toString() : String.fromCharCode( event.keyCode );
1614
1615                         clearTimeout( this.filterTimer );
1616
1617                         if ( character === prev ) {
1618                                 skip = true;
1619                         } else {
1620                                 character = prev + character;
1621                         }
1622
1623                         match = this._filterMenuItems( character );
1624                         match = skip && match.index( this.active.next() ) !== -1 ?
1625                                 this.active.nextAll( ".ui-menu-item" ) :
1626                                 match;
1627
1628                         // If no matches on the current filter, reset to the last character pressed
1629                         // to move down the menu to the first item that starts with that character
1630                         if ( !match.length ) {
1631                                 character = String.fromCharCode( event.keyCode );
1632                                 match = this._filterMenuItems( character );
1633                         }
1634
1635                         if ( match.length ) {
1636                                 this.focus( event, match );
1637                                 this.previousFilter = character;
1638                                 this.filterTimer = this._delay( function() {
1639                                         delete this.previousFilter;
1640                                 }, 1000 );
1641                         } else {
1642                                 delete this.previousFilter;
1643                         }
1644                 }
1645
1646                 if ( preventDefault ) {
1647                         event.preventDefault();
1648                 }
1649         },
1650
1651         _activate: function( event ) {
1652                 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
1653                         if ( this.active.children( "[aria-haspopup='true']" ).length ) {
1654                                 this.expand( event );
1655                         } else {
1656                                 this.select( event );
1657                         }
1658                 }
1659         },
1660
1661         refresh: function() {
1662                 var menus, items, newSubmenus, newItems, newWrappers,
1663                         that = this,
1664                         icon = this.options.icons.submenu,
1665                         submenus = this.element.find( this.options.menus );
1666
1667                 this._toggleClass( "ui-menu-icons", null, !!this.element.find( ".ui-icon" ).length );
1668
1669                 // Initialize nested menus
1670                 newSubmenus = submenus.filter( ":not(.ui-menu)" )
1671                         .hide()
1672                         .attr( {
1673                                 role: this.options.role,
1674                                 "aria-hidden": "true",
1675                                 "aria-expanded": "false"
1676                         } )
1677                         .each( function() {
1678                                 var menu = $( this ),
1679                                         item = menu.prev(),
1680                                         submenuCaret = $( "<span>" ).data( "ui-menu-submenu-caret", true );
1681
1682                                 that._addClass( submenuCaret, "ui-menu-icon", "ui-icon " + icon );
1683                                 item
1684                                         .attr( "aria-haspopup", "true" )
1685                                         .prepend( submenuCaret );
1686                                 menu.attr( "aria-labelledby", item.attr( "id" ) );
1687                         } );
1688
1689                 this._addClass( newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front" );
1690
1691                 menus = submenus.add( this.element );
1692                 items = menus.find( this.options.items );
1693
1694                 // Initialize menu-items containing spaces and/or dashes only as dividers
1695                 items.not( ".ui-menu-item" ).each( function() {
1696                         var item = $( this );
1697                         if ( that._isDivider( item ) ) {
1698                                 that._addClass( item, "ui-menu-divider", "ui-widget-content" );
1699                         }
1700                 } );
1701
1702                 // Don't refresh list items that are already adapted
1703                 newItems = items.not( ".ui-menu-item, .ui-menu-divider" );
1704                 newWrappers = newItems.children()
1705                         .not( ".ui-menu" )
1706                                 .uniqueId()
1707                                 .attr( {
1708                                         tabIndex: -1,
1709                                         role: this._itemRole()
1710                                 } );
1711                 this._addClass( newItems, "ui-menu-item" )
1712                         ._addClass( newWrappers, "ui-menu-item-wrapper" );
1713
1714                 // Add aria-disabled attribute to any disabled menu item
1715                 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
1716
1717                 // If the active item has been removed, blur the menu
1718                 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1719                         this.blur();
1720                 }
1721         },
1722
1723         _itemRole: function() {
1724                 return {
1725                         menu: "menuitem",
1726                         listbox: "option"
1727                 }[ this.options.role ];
1728         },
1729
1730         _setOption: function( key, value ) {
1731                 if ( key === "icons" ) {
1732                         var icons = this.element.find( ".ui-menu-icon" );
1733                         this._removeClass( icons, null, this.options.icons.submenu )
1734                                 ._addClass( icons, null, value.submenu );
1735                 }
1736                 this._super( key, value );
1737         },
1738
1739         _setOptionDisabled: function( value ) {
1740                 this._super( value );
1741
1742                 this.element.attr( "aria-disabled", String( value ) );
1743                 this._toggleClass( null, "ui-state-disabled", !!value );
1744         },
1745
1746         focus: function( event, item ) {
1747                 var nested, focused, activeParent;
1748                 this.blur( event, event && event.type === "focus" );
1749
1750                 this._scrollIntoView( item );
1751
1752                 this.active = item.first();
1753
1754                 focused = this.active.children( ".ui-menu-item-wrapper" );
1755                 this._addClass( focused, null, "ui-state-active" );
1756
1757                 // Only update aria-activedescendant if there's a role
1758                 // otherwise we assume focus is managed elsewhere
1759                 if ( this.options.role ) {
1760                         this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
1761                 }
1762
1763                 // Highlight active parent menu item, if any
1764                 activeParent = this.active
1765                         .parent()
1766                                 .closest( ".ui-menu-item" )
1767                                         .children( ".ui-menu-item-wrapper" );
1768                 this._addClass( activeParent, null, "ui-state-active" );
1769
1770                 if ( event && event.type === "keydown" ) {
1771                         this._close();
1772                 } else {
1773                         this.timer = this._delay( function() {
1774                                 this._close();
1775                         }, this.delay );
1776                 }
1777
1778                 nested = item.children( ".ui-menu" );
1779                 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
1780                         this._startOpening( nested );
1781                 }
1782                 this.activeMenu = item.parent();
1783
1784                 this._trigger( "focus", event, { item: item } );
1785         },
1786
1787         _scrollIntoView: function( item ) {
1788                 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
1789                 if ( this._hasScroll() ) {
1790                         borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0;
1791                         paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0;
1792                         offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
1793                         scroll = this.activeMenu.scrollTop();
1794                         elementHeight = this.activeMenu.height();
1795                         itemHeight = item.outerHeight();
1796
1797                         if ( offset < 0 ) {
1798                                 this.activeMenu.scrollTop( scroll + offset );
1799                         } else if ( offset + itemHeight > elementHeight ) {
1800                                 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
1801                         }
1802                 }
1803         },
1804
1805         blur: function( event, fromFocus ) {
1806                 if ( !fromFocus ) {
1807                         clearTimeout( this.timer );
1808                 }
1809
1810                 if ( !this.active ) {
1811                         return;
1812                 }
1813
1814                 this._removeClass( this.active.children( ".ui-menu-item-wrapper" ),
1815                         null, "ui-state-active" );
1816
1817                 this._trigger( "blur", event, { item: this.active } );
1818                 this.active = null;
1819         },
1820
1821         _startOpening: function( submenu ) {
1822                 clearTimeout( this.timer );
1823
1824                 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
1825                 // shift in the submenu position when mousing over the caret icon
1826                 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
1827                         return;
1828                 }
1829
1830                 this.timer = this._delay( function() {
1831                         this._close();
1832                         this._open( submenu );
1833                 }, this.delay );
1834         },
1835
1836         _open: function( submenu ) {
1837                 var position = $.extend( {
1838                         of: this.active
1839                 }, this.options.position );
1840
1841                 clearTimeout( this.timer );
1842                 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
1843                         .hide()
1844                         .attr( "aria-hidden", "true" );
1845
1846                 submenu
1847                         .show()
1848                         .removeAttr( "aria-hidden" )
1849                         .attr( "aria-expanded", "true" )
1850                         .position( position );
1851         },
1852
1853         collapseAll: function( event, all ) {
1854                 clearTimeout( this.timer );
1855                 this.timer = this._delay( function() {
1856
1857                         // If we were passed an event, look for the submenu that contains the event
1858                         var currentMenu = all ? this.element :
1859                                 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
1860
1861                         // If we found no valid submenu ancestor, use the main menu to close all
1862                         // sub menus anyway
1863                         if ( !currentMenu.length ) {
1864                                 currentMenu = this.element;
1865                         }
1866
1867                         this._close( currentMenu );
1868
1869                         this.blur( event );
1870
1871                         // Work around active item staying active after menu is blurred
1872                         this._removeClass( currentMenu.find( ".ui-state-active" ), null, "ui-state-active" );
1873
1874                         this.activeMenu = currentMenu;
1875                 }, all ? 0 : this.delay );
1876         },
1877
1878         // With no arguments, closes the currently active menu - if nothing is active
1879         // it closes all menus.  If passed an argument, it will search for menus BELOW
1880         _close: function( startMenu ) {
1881                 if ( !startMenu ) {
1882                         startMenu = this.active ? this.active.parent() : this.element;
1883                 }
1884
1885                 startMenu.find( ".ui-menu" )
1886                         .hide()
1887                         .attr( "aria-hidden", "true" )
1888                         .attr( "aria-expanded", "false" );
1889         },
1890
1891         _closeOnDocumentClick: function( event ) {
1892                 return !$( event.target ).closest( ".ui-menu" ).length;
1893         },
1894
1895         _isDivider: function( item ) {
1896
1897                 // Match hyphen, em dash, en dash
1898                 return !/[^\-\u2014\u2013\s]/.test( item.text() );
1899         },
1900
1901         collapse: function( event ) {
1902                 var newItem = this.active &&
1903                         this.active.parent().closest( ".ui-menu-item", this.element );
1904                 if ( newItem && newItem.length ) {
1905                         this._close();
1906                         this.focus( event, newItem );
1907                 }
1908         },
1909
1910         expand: function( event ) {
1911                 var newItem = this.active && this._menuItems( this.active.children( ".ui-menu" ) ).first();
1912
1913                 if ( newItem && newItem.length ) {
1914                         this._open( newItem.parent() );
1915
1916                         // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
1917                         this._delay( function() {
1918                                 this.focus( event, newItem );
1919                         } );
1920                 }
1921         },
1922
1923         next: function( event ) {
1924                 this._move( "next", "first", event );
1925         },
1926
1927         previous: function( event ) {
1928                 this._move( "prev", "last", event );
1929         },
1930
1931         isFirstItem: function() {
1932                 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
1933         },
1934
1935         isLastItem: function() {
1936                 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
1937         },
1938
1939         _menuItems: function( menu ) {
1940                 return ( menu || this.element )
1941                         .find( this.options.items )
1942                         .filter( ".ui-menu-item" );
1943         },
1944
1945         _move: function( direction, filter, event ) {
1946                 var next;
1947                 if ( this.active ) {
1948                         if ( direction === "first" || direction === "last" ) {
1949                                 next = this.active
1950                                         [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
1951                                         .last();
1952                         } else {
1953                                 next = this.active
1954                                         [ direction + "All" ]( ".ui-menu-item" )
1955                                         .first();
1956                         }
1957                 }
1958                 if ( !next || !next.length || !this.active ) {
1959                         next = this._menuItems( this.activeMenu )[ filter ]();
1960                 }
1961
1962                 this.focus( event, next );
1963         },
1964
1965         nextPage: function( event ) {
1966                 var item, base, height;
1967
1968                 if ( !this.active ) {
1969                         this.next( event );
1970                         return;
1971                 }
1972                 if ( this.isLastItem() ) {
1973                         return;
1974                 }
1975                 if ( this._hasScroll() ) {
1976                         base = this.active.offset().top;
1977                         height = this.element.innerHeight();
1978
1979                         // jQuery 3.2 doesn't include scrollbars in innerHeight, add it back.
1980                         if ( $.fn.jquery.indexOf( "3.2." ) === 0 ) {
1981                                 height += this.element[ 0 ].offsetHeight - this.element.outerHeight();
1982                         }
1983
1984                         this.active.nextAll( ".ui-menu-item" ).each( function() {
1985                                 item = $( this );
1986                                 return item.offset().top - base - height < 0;
1987                         } );
1988
1989                         this.focus( event, item );
1990                 } else {
1991                         this.focus( event, this._menuItems( this.activeMenu )
1992                                 [ !this.active ? "first" : "last" ]() );
1993                 }
1994         },
1995
1996         previousPage: function( event ) {
1997                 var item, base, height;
1998                 if ( !this.active ) {
1999                         this.next( event );
2000                         return;
2001                 }
2002                 if ( this.isFirstItem() ) {
2003                         return;
2004                 }
2005                 if ( this._hasScroll() ) {
2006                         base = this.active.offset().top;
2007                         height = this.element.innerHeight();
2008
2009                         // jQuery 3.2 doesn't include scrollbars in innerHeight, add it back.
2010                         if ( $.fn.jquery.indexOf( "3.2." ) === 0 ) {
2011                                 height += this.element[ 0 ].offsetHeight - this.element.outerHeight();
2012                         }
2013
2014                         this.active.prevAll( ".ui-menu-item" ).each( function() {
2015                                 item = $( this );
2016                                 return item.offset().top - base + height > 0;
2017                         } );
2018
2019                         this.focus( event, item );
2020                 } else {
2021                         this.focus( event, this._menuItems( this.activeMenu ).first() );
2022                 }
2023         },
2024
2025         _hasScroll: function() {
2026                 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2027         },
2028
2029         select: function( event ) {
2030
2031                 // TODO: It should never be possible to not have an active item at this
2032                 // point, but the tests don't trigger mouseenter before click.
2033                 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2034                 var ui = { item: this.active };
2035                 if ( !this.active.has( ".ui-menu" ).length ) {
2036                         this.collapseAll( event, true );
2037                 }
2038                 this._trigger( "select", event, ui );
2039         },
2040
2041         _filterMenuItems: function( character ) {
2042                 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2043                         regex = new RegExp( "^" + escapedCharacter, "i" );
2044
2045                 return this.activeMenu
2046                         .find( this.options.items )
2047
2048                                 // Only match on items, not dividers or other content (#10571)
2049                                 .filter( ".ui-menu-item" )
2050                                         .filter( function() {
2051                                                 return regex.test(
2052                                                         String.prototype.trim.call(
2053                                                                 $( this ).children( ".ui-menu-item-wrapper" ).text() ) );
2054                                         } );
2055         }
2056 } );
2057
2058
2059 /*!
2060  * jQuery UI Autocomplete 1.13.1
2061  * http://jqueryui.com
2062  *
2063  * Copyright jQuery Foundation and other contributors
2064  * Released under the MIT license.
2065  * http://jquery.org/license
2066  */
2067
2068 //>>label: Autocomplete
2069 //>>group: Widgets
2070 //>>description: Lists suggested words as the user is typing.
2071 //>>docs: http://api.jqueryui.com/autocomplete/
2072 //>>demos: http://jqueryui.com/autocomplete/
2073 //>>css.structure: ../../themes/base/core.css
2074 //>>css.structure: ../../themes/base/autocomplete.css
2075 //>>css.theme: ../../themes/base/theme.css
2076
2077
2078 $.widget( "ui.autocomplete", {
2079         version: "1.13.1",
2080         defaultElement: "<input>",
2081         options: {
2082                 appendTo: null,
2083                 autoFocus: false,
2084                 delay: 300,
2085                 minLength: 1,
2086                 position: {
2087                         my: "left top",
2088                         at: "left bottom",
2089                         collision: "none"
2090                 },
2091                 source: null,
2092
2093                 // Callbacks
2094                 change: null,
2095                 close: null,
2096                 focus: null,
2097                 open: null,
2098                 response: null,
2099                 search: null,
2100                 select: null
2101         },
2102
2103         requestIndex: 0,
2104         pending: 0,
2105         liveRegionTimer: null,
2106
2107         _create: function() {
2108
2109                 // Some browsers only repeat keydown events, not keypress events,
2110                 // so we use the suppressKeyPress flag to determine if we've already
2111                 // handled the keydown event. #7269
2112                 // Unfortunately the code for & in keypress is the same as the up arrow,
2113                 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2114                 // events when we know the keydown event was used to modify the
2115                 // search term. #7799
2116                 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2117                         nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2118                         isTextarea = nodeName === "textarea",
2119                         isInput = nodeName === "input";
2120
2121                 // Textareas are always multi-line
2122                 // Inputs are always single-line, even if inside a contentEditable element
2123                 // IE also treats inputs as contentEditable
2124                 // All other element types are determined by whether or not they're contentEditable
2125                 this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );
2126
2127                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2128                 this.isNewMenu = true;
2129
2130                 this._addClass( "ui-autocomplete-input" );
2131                 this.element.attr( "autocomplete", "off" );
2132
2133                 this._on( this.element, {
2134                         keydown: function( event ) {
2135                                 if ( this.element.prop( "readOnly" ) ) {
2136                                         suppressKeyPress = true;
2137                                         suppressInput = true;
2138                                         suppressKeyPressRepeat = true;
2139                                         return;
2140                                 }
2141
2142                                 suppressKeyPress = false;
2143                                 suppressInput = false;
2144                                 suppressKeyPressRepeat = false;
2145                                 var keyCode = $.ui.keyCode;
2146                                 switch ( event.keyCode ) {
2147                                 case keyCode.PAGE_UP:
2148                                         suppressKeyPress = true;
2149                                         this._move( "previousPage", event );
2150                                         break;
2151                                 case keyCode.PAGE_DOWN:
2152                                         suppressKeyPress = true;
2153                                         this._move( "nextPage", event );
2154                                         break;
2155                                 case keyCode.UP:
2156                                         suppressKeyPress = true;
2157                                         this._keyEvent( "previous", event );
2158                                         break;
2159                                 case keyCode.DOWN:
2160                                         suppressKeyPress = true;
2161                                         this._keyEvent( "next", event );
2162                                         break;
2163                                 case keyCode.ENTER:
2164
2165                                         // when menu is open and has focus
2166                                         if ( this.menu.active ) {
2167
2168                                                 // #6055 - Opera still allows the keypress to occur
2169                                                 // which causes forms to submit
2170                                                 suppressKeyPress = true;
2171                                                 event.preventDefault();
2172                                                 this.menu.select( event );
2173                                         }
2174                                         break;
2175                                 case keyCode.TAB:
2176                                         if ( this.menu.active ) {
2177                                                 this.menu.select( event );
2178                                         }
2179                                         break;
2180                                 case keyCode.ESCAPE:
2181                                         if ( this.menu.element.is( ":visible" ) ) {
2182                                                 if ( !this.isMultiLine ) {
2183                                                         this._value( this.term );
2184                                                 }
2185                                                 this.close( event );
2186
2187                                                 // Different browsers have different default behavior for escape
2188                                                 // Single press can mean undo or clear
2189                                                 // Double press in IE means clear the whole form
2190                                                 event.preventDefault();
2191                                         }
2192                                         break;
2193                                 default:
2194                                         suppressKeyPressRepeat = true;
2195
2196                                         // search timeout should be triggered before the input value is changed
2197                                         this._searchTimeout( event );
2198                                         break;
2199                                 }
2200                         },
2201                         keypress: function( event ) {
2202                                 if ( suppressKeyPress ) {
2203                                         suppressKeyPress = false;
2204                                         if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2205                                                 event.preventDefault();
2206                                         }
2207                                         return;
2208                                 }
2209                                 if ( suppressKeyPressRepeat ) {
2210                                         return;
2211                                 }
2212
2213                                 // Replicate some key handlers to allow them to repeat in Firefox and Opera
2214                                 var keyCode = $.ui.keyCode;
2215                                 switch ( event.keyCode ) {
2216                                 case keyCode.PAGE_UP:
2217                                         this._move( "previousPage", event );
2218                                         break;
2219                                 case keyCode.PAGE_DOWN:
2220                                         this._move( "nextPage", event );
2221                                         break;
2222                                 case keyCode.UP:
2223                                         this._keyEvent( "previous", event );
2224                                         break;
2225                                 case keyCode.DOWN:
2226                                         this._keyEvent( "next", event );
2227                                         break;
2228                                 }
2229                         },
2230                         input: function( event ) {
2231                                 if ( suppressInput ) {
2232                                         suppressInput = false;
2233                                         event.preventDefault();
2234                                         return;
2235                                 }
2236                                 this._searchTimeout( event );
2237                         },
2238                         focus: function() {
2239                                 this.selectedItem = null;
2240                                 this.previous = this._value();
2241                         },
2242                         blur: function( event ) {
2243                                 clearTimeout( this.searching );
2244                                 this.close( event );
2245                                 this._change( event );
2246                         }
2247                 } );
2248
2249                 this._initSource();
2250                 this.menu = $( "<ul>" )
2251                         .appendTo( this._appendTo() )
2252                         .menu( {
2253
2254                                 // disable ARIA support, the live region takes care of that
2255                                 role: null
2256                         } )
2257                         .hide()
2258
2259                         // Support: IE 11 only, Edge <= 14
2260                         // For other browsers, we preventDefault() on the mousedown event
2261                         // to keep the dropdown from taking focus from the input. This doesn't
2262                         // work for IE/Edge, causing problems with selection and scrolling (#9638)
2263                         // Happily, IE and Edge support an "unselectable" attribute that
2264                         // prevents an element from receiving focus, exactly what we want here.
2265                         .attr( {
2266                                 "unselectable": "on"
2267                         } )
2268                         .menu( "instance" );
2269
2270                 this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );
2271                 this._on( this.menu.element, {
2272                         mousedown: function( event ) {
2273
2274                                 // Prevent moving focus out of the text field
2275                                 event.preventDefault();
2276                         },
2277                         menufocus: function( event, ui ) {
2278                                 var label, item;
2279
2280                                 // support: Firefox
2281                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2282                                 if ( this.isNewMenu ) {
2283                                         this.isNewMenu = false;
2284                                         if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2285                                                 this.menu.blur();
2286
2287                                                 this.document.one( "mousemove", function() {
2288                                                         $( event.target ).trigger( event.originalEvent );
2289                                                 } );
2290
2291                                                 return;
2292                                         }
2293                                 }
2294
2295                                 item = ui.item.data( "ui-autocomplete-item" );
2296                                 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
2297
2298                                         // use value to match what will end up in the input, if it was a key event
2299                                         if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
2300                                                 this._value( item.value );
2301                                         }
2302                                 }
2303
2304                                 // Announce the value in the liveRegion
2305                                 label = ui.item.attr( "aria-label" ) || item.value;
2306                                 if ( label && String.prototype.trim.call( label ).length ) {
2307                                         clearTimeout( this.liveRegionTimer );
2308                                         this.liveRegionTimer = this._delay( function() {
2309                                                 this.liveRegion.html( $( "<div>" ).text( label ) );
2310                                         }, 100 );
2311                                 }
2312                         },
2313                         menuselect: function( event, ui ) {
2314                                 var item = ui.item.data( "ui-autocomplete-item" ),
2315                                         previous = this.previous;
2316
2317                                 // Only trigger when focus was lost (click on menu)
2318                                 if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
2319                                         this.element.trigger( "focus" );
2320                                         this.previous = previous;
2321
2322                                         // #6109 - IE triggers two focus events and the second
2323                                         // is asynchronous, so we need to reset the previous
2324                                         // term synchronously and asynchronously :-(
2325                                         this._delay( function() {
2326                                                 this.previous = previous;
2327                                                 this.selectedItem = item;
2328                                         } );
2329                                 }
2330
2331                                 if ( false !== this._trigger( "select", event, { item: item } ) ) {
2332                                         this._value( item.value );
2333                                 }
2334
2335                                 // reset the term after the select event
2336                                 // this allows custom select handling to work properly
2337                                 this.term = this._value();
2338
2339                                 this.close( event );
2340                                 this.selectedItem = item;
2341                         }
2342                 } );
2343
2344                 this.liveRegion = $( "<div>", {
2345                         role: "status",
2346                         "aria-live": "assertive",
2347                         "aria-relevant": "additions"
2348                 } )
2349                         .appendTo( this.document[ 0 ].body );
2350
2351                 this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );
2352
2353                 // Turning off autocomplete prevents the browser from remembering the
2354                 // value when navigating through history, so we re-enable autocomplete
2355                 // if the page is unloaded before the widget is destroyed. #7790
2356                 this._on( this.window, {
2357                         beforeunload: function() {
2358                                 this.element.removeAttr( "autocomplete" );
2359                         }
2360                 } );
2361         },
2362
2363         _destroy: function() {
2364                 clearTimeout( this.searching );
2365                 this.element.removeAttr( "autocomplete" );
2366                 this.menu.element.remove();
2367                 this.liveRegion.remove();
2368         },
2369
2370         _setOption: function( key, value ) {
2371                 this._super( key, value );
2372                 if ( key === "source" ) {
2373                         this._initSource();
2374                 }
2375                 if ( key === "appendTo" ) {
2376                         this.menu.element.appendTo( this._appendTo() );
2377                 }
2378                 if ( key === "disabled" && value && this.xhr ) {
2379                         this.xhr.abort();
2380                 }
2381         },
2382
2383         _isEventTargetInWidget: function( event ) {
2384                 var menuElement = this.menu.element[ 0 ];
2385
2386                 return event.target === this.element[ 0 ] ||
2387                         event.target === menuElement ||
2388                         $.contains( menuElement, event.target );
2389         },
2390
2391         _closeOnClickOutside: function( event ) {
2392                 if ( !this._isEventTargetInWidget( event ) ) {
2393                         this.close();
2394                 }
2395         },
2396
2397         _appendTo: function() {
2398                 var element = this.options.appendTo;
2399
2400                 if ( element ) {
2401                         element = element.jquery || element.nodeType ?
2402                                 $( element ) :
2403                                 this.document.find( element ).eq( 0 );
2404                 }
2405
2406                 if ( !element || !element[ 0 ] ) {
2407                         element = this.element.closest( ".ui-front, dialog" );
2408                 }
2409
2410                 if ( !element.length ) {
2411                         element = this.document[ 0 ].body;
2412                 }
2413
2414                 return element;
2415         },
2416
2417         _initSource: function() {
2418                 var array, url,
2419                         that = this;
2420                 if ( Array.isArray( this.options.source ) ) {
2421                         array = this.options.source;
2422                         this.source = function( request, response ) {
2423                                 response( $.ui.autocomplete.filter( array, request.term ) );
2424                         };
2425                 } else if ( typeof this.options.source === "string" ) {
2426                         url = this.options.source;
2427                         this.source = function( request, response ) {
2428                                 if ( that.xhr ) {
2429                                         that.xhr.abort();
2430                                 }
2431                                 that.xhr = $.ajax( {
2432                                         url: url,
2433                                         data: request,
2434                                         dataType: "json",
2435                                         success: function( data ) {
2436                                                 response( data );
2437                                         },
2438                                         error: function() {
2439                                                 response( [] );
2440                                         }
2441                                 } );
2442                         };
2443                 } else {
2444                         this.source = this.options.source;
2445                 }
2446         },
2447
2448         _searchTimeout: function( event ) {
2449                 clearTimeout( this.searching );
2450                 this.searching = this._delay( function() {
2451
2452                         // Search if the value has changed, or if the user retypes the same value (see #7434)
2453                         var equalValues = this.term === this._value(),
2454                                 menuVisible = this.menu.element.is( ":visible" ),
2455                                 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
2456
2457                         if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
2458                                 this.selectedItem = null;
2459                                 this.search( null, event );
2460                         }
2461                 }, this.options.delay );
2462         },
2463
2464         search: function( value, event ) {
2465                 value = value != null ? value : this._value();
2466
2467                 // Always save the actual value, not the one passed as an argument
2468                 this.term = this._value();
2469
2470                 if ( value.length < this.options.minLength ) {
2471                         return this.close( event );
2472                 }
2473
2474                 if ( this._trigger( "search", event ) === false ) {
2475                         return;
2476                 }
2477
2478                 return this._search( value );
2479         },
2480
2481         _search: function( value ) {
2482                 this.pending++;
2483                 this._addClass( "ui-autocomplete-loading" );
2484                 this.cancelSearch = false;
2485
2486                 this.source( { term: value }, this._response() );
2487         },
2488
2489         _response: function() {
2490                 var index = ++this.requestIndex;
2491
2492                 return function( content ) {
2493                         if ( index === this.requestIndex ) {
2494                                 this.__response( content );
2495                         }
2496
2497                         this.pending--;
2498                         if ( !this.pending ) {
2499                                 this._removeClass( "ui-autocomplete-loading" );
2500                         }
2501                 }.bind( this );
2502         },
2503
2504         __response: function( content ) {
2505                 if ( content ) {
2506                         content = this._normalize( content );
2507                 }
2508                 this._trigger( "response", null, { content: content } );
2509                 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
2510                         this._suggest( content );
2511                         this._trigger( "open" );
2512                 } else {
2513
2514                         // use ._close() instead of .close() so we don't cancel future searches
2515                         this._close();
2516                 }
2517         },
2518
2519         close: function( event ) {
2520                 this.cancelSearch = true;
2521                 this._close( event );
2522         },
2523
2524         _close: function( event ) {
2525
2526                 // Remove the handler that closes the menu on outside clicks
2527                 this._off( this.document, "mousedown" );
2528
2529                 if ( this.menu.element.is( ":visible" ) ) {
2530                         this.menu.element.hide();
2531                         this.menu.blur();
2532                         this.isNewMenu = true;
2533                         this._trigger( "close", event );
2534                 }
2535         },
2536
2537         _change: function( event ) {
2538                 if ( this.previous !== this._value() ) {
2539                         this._trigger( "change", event, { item: this.selectedItem } );
2540                 }
2541         },
2542
2543         _normalize: function( items ) {
2544
2545                 // assume all items have the right format when the first item is complete
2546                 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
2547                         return items;
2548                 }
2549                 return $.map( items, function( item ) {
2550                         if ( typeof item === "string" ) {
2551                                 return {
2552                                         label: item,
2553                                         value: item
2554                                 };
2555                         }
2556                         return $.extend( {}, item, {
2557                                 label: item.label || item.value,
2558                                 value: item.value || item.label
2559                         } );
2560                 } );
2561         },
2562
2563         _suggest: function( items ) {
2564                 var ul = this.menu.element.empty();
2565                 this._renderMenu( ul, items );
2566                 this.isNewMenu = true;
2567                 this.menu.refresh();
2568
2569                 // Size and position menu
2570                 ul.show();
2571                 this._resizeMenu();
2572                 ul.position( $.extend( {
2573                         of: this.element
2574                 }, this.options.position ) );
2575
2576                 if ( this.options.autoFocus ) {
2577                         this.menu.next();
2578                 }
2579
2580                 // Listen for interactions outside of the widget (#6642)
2581                 this._on( this.document, {
2582                         mousedown: "_closeOnClickOutside"
2583                 } );
2584         },
2585
2586         _resizeMenu: function() {
2587                 var ul = this.menu.element;
2588                 ul.outerWidth( Math.max(
2589
2590                         // Firefox wraps long text (possibly a rounding bug)
2591                         // so we add 1px to avoid the wrapping (#7513)
2592                         ul.width( "" ).outerWidth() + 1,
2593                         this.element.outerWidth()
2594                 ) );
2595         },
2596
2597         _renderMenu: function( ul, items ) {
2598                 var that = this;
2599                 $.each( items, function( index, item ) {
2600                         that._renderItemData( ul, item );
2601                 } );
2602         },
2603
2604         _renderItemData: function( ul, item ) {
2605                 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
2606         },
2607
2608         _renderItem: function( ul, item ) {
2609                 return $( "<li>" )
2610                         .append( $( "<div>" ).text( item.label ) )
2611                         .appendTo( ul );
2612         },
2613
2614         _move: function( direction, event ) {
2615                 if ( !this.menu.element.is( ":visible" ) ) {
2616                         this.search( null, event );
2617                         return;
2618                 }
2619                 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
2620                                 this.menu.isLastItem() && /^next/.test( direction ) ) {
2621
2622                         if ( !this.isMultiLine ) {
2623                                 this._value( this.term );
2624                         }
2625
2626                         this.menu.blur();
2627                         return;
2628                 }
2629                 this.menu[ direction ]( event );
2630         },
2631
2632         widget: function() {
2633                 return this.menu.element;
2634         },
2635
2636         _value: function() {
2637                 return this.valueMethod.apply( this.element, arguments );
2638         },
2639
2640         _keyEvent: function( keyEvent, event ) {
2641                 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2642                         this._move( keyEvent, event );
2643
2644                         // Prevents moving cursor to beginning/end of the text field in some browsers
2645                         event.preventDefault();
2646                 }
2647         },
2648
2649         // Support: Chrome <=50
2650         // We should be able to just use this.element.prop( "isContentEditable" )
2651         // but hidden elements always report false in Chrome.
2652         // https://code.google.com/p/chromium/issues/detail?id=313082
2653         _isContentEditable: function( element ) {
2654                 if ( !element.length ) {
2655                         return false;
2656                 }
2657
2658                 var editable = element.prop( "contentEditable" );
2659
2660                 if ( editable === "inherit" ) {
2661                         return this._isContentEditable( element.parent() );
2662                 }
2663
2664                 return editable === "true";
2665         }
2666 } );
2667
2668 $.extend( $.ui.autocomplete, {
2669         escapeRegex: function( value ) {
2670                 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
2671         },
2672         filter: function( array, term ) {
2673                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
2674                 return $.grep( array, function( value ) {
2675                         return matcher.test( value.label || value.value || value );
2676                 } );
2677         }
2678 } );
2679
2680 // Live region extension, adding a `messages` option
2681 // NOTE: This is an experimental API. We are still investigating
2682 // a full solution for string manipulation and internationalization.
2683 $.widget( "ui.autocomplete", $.ui.autocomplete, {
2684         options: {
2685                 messages: {
2686                         noResults: "No search results.",
2687                         results: function( amount ) {
2688                                 return amount + ( amount > 1 ? " results are" : " result is" ) +
2689                                         " available, use up and down arrow keys to navigate.";
2690                         }
2691                 }
2692         },
2693
2694         __response: function( content ) {
2695                 var message;
2696                 this._superApply( arguments );
2697                 if ( this.options.disabled || this.cancelSearch ) {
2698                         return;
2699                 }
2700                 if ( content && content.length ) {
2701                         message = this.options.messages.results( content.length );
2702                 } else {
2703                         message = this.options.messages.noResults;
2704                 }
2705                 clearTimeout( this.liveRegionTimer );
2706                 this.liveRegionTimer = this._delay( function() {
2707                         this.liveRegion.html( $( "<div>" ).text( message ) );
2708                 }, 100 );
2709         }
2710 } );
2711
2712 var widgetsAutocomplete = $.ui.autocomplete;
2713
2714
2715
2716
2717 } );