https://www.nasponline.org/assets/Documents/Prebuilt/js/jquery-ui-1.11.4.js

1/*! jQuery UI - v1.11.4 - 2015-03-11
2* http://jqueryui.com
3* Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
4* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
5
6(function( factory ) {
7	if ( typeof define === "function" && define.amd ) {
8
9		// AMD. Register as an anonymous module.
10		define([ "jquery" ], factory );
11	} else {
12
13		// Browser globals
14		factory( jQuery );
15	}
16}(function( $ ) {
17/*!
18 * jQuery UI Core 1.11.4
19 * http://jqueryui.com
20 *
21 * Copyright jQuery Foundation and other contributors
22 * Released under the MIT license.
23 * http://jquery.org/license
24 *
25 * http://api.jqueryui.com/category/ui-core/
26 */
27
28
29// $.ui might exist from components with no dependencies, e.g., $.ui.position
30$.ui = $.ui || {};
31
32$.extend( $.ui, {
33	version: "1.11.4",
34
35	keyCode: {
36		BACKSPACE: 8,
37		COMMA: 188,
38		DELETE: 46,
39		DOWN: 40,
40		END: 35,
41		ENTER: 13,
42		ESCAPE: 27,
43		HOME: 36,
44		LEFT: 37,
45		PAGE_DOWN: 34,
46		PAGE_UP: 33,
47		PERIOD: 190,
48		RIGHT: 39,
49		SPACE: 32,
50		TAB: 9,
51		UP: 38
52	}
53});
54
55// plugins
56$.fn.extend({
57	scrollParent: function( includeHidden ) {
58		var position = this.css( "position" ),
59			excludeStaticParent = position === "absolute",
60			overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
61			scrollParent = this.parents().filter( function() {
62				var parent = $( this );
63				if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
64					return false;
65				}
66				return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
67			}).eq( 0 );
68
69		return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
70	},
71
72	uniqueId: (function() {
73		var uuid = 0;
74
75		return function() {
76			return this.each(function() {
77				if ( !this.id ) {
78					this.id = "ui-id-" + ( ++uuid );
79				}
80			});
81		};
82	})(),
83
84	removeUniqueId: function() {
85		return this.each(function() {
86			if ( /^ui-id-\d+$/.test( this.id ) ) {
87				$( this ).removeAttr( "id" );
88			}
89		});
90	}
91});
92
93// selectors
94function focusable( element, isTabIndexNotNaN ) {
95	var map, mapName, img,
96		nodeName = element.nodeName.toLowerCase();
97	if ( "area" === nodeName ) {
98		map = element.parentNode;
99		mapName = map.name;
100		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
101			return false;
102		}
103		img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
104		return !!img && visible( img );
105	}
106	return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ?
107		!element.disabled :
108		"a" === nodeName ?
109			element.href || isTabIndexNotNaN :
110			isTabIndexNotNaN) &&
111		// the element and all of its ancestors must be visible
112		visible( element );
113}
114
115function visible( element ) {
116	return $.expr.filters.visible( element ) &&
117		!$( element ).parents().addBack().filter(function() {
118			return $.css( this, "visibility" ) === "hidden";
119		}).length;
120}
121
122$.extend( $.expr[ ":" ], {
123	data: $.expr.createPseudo ?
124		$.expr.createPseudo(function( dataName ) {
125			return function( elem ) {
126				return !!$.data( elem, dataName );
127			};
128		}) :
129		// support: jQuery <1.8
130		function( elem, i, match ) {
131			return !!$.data( elem, match[ 3 ] );
132		},
133
134	focusable: function( element ) {
135		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
136	},
137
138	tabbable: function( element ) {
139		var tabIndex = $.attr( element, "tabindex" ),
140			isTabIndexNaN = isNaN( tabIndex );
141		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
142	}
143});
144
145// support: jQuery <1.8
146if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
147	$.each( [ "Width", "Height" ], function( i, name ) {
148		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
149			type = name.toLowerCase(),
150			orig = {
151				innerWidth: $.fn.innerWidth,
152				innerHeight: $.fn.innerHeight,
153				outerWidth: $.fn.outerWidth,
154				outerHeight: $.fn.outerHeight
155			};
156
157		function reduce( elem, size, border, margin ) {
158			$.each( side, function() {
159				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
160				if ( border ) {
161					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
162				}
163				if ( margin ) {
164					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
165				}
166			});
167			return size;
168		}
169
170		$.fn[ "inner" + name ] = function( size ) {
171			if ( size === undefined ) {
172				return orig[ "inner" + name ].call( this );
173			}
174
175			return this.each(function() {
176				$( this ).css( type, reduce( this, size ) + "px" );
177			});
178		};
179
180		$.fn[ "outer" + name] = function( size, margin ) {
181			if ( typeof size !== "number" ) {
182				return orig[ "outer" + name ].call( this, size );
183			}
184
185			return this.each(function() {
186				$( this).css( type, reduce( this, size, true, margin ) + "px" );
187			});
188		};
189	});
190}
191
192// support: jQuery <1.8
193if ( !$.fn.addBack ) {
194	$.fn.addBack = function( selector ) {
195		return this.add( selector == null ?
196			this.prevObject : this.prevObject.filter( selector )
197		);
198	};
199}
200
201// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
202if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
203	$.fn.removeData = (function( removeData ) {
204		return function( key ) {
205			if ( arguments.length ) {
206				return removeData.call( this, $.camelCase( key ) );
207			} else {
208				return removeData.call( this );
209			}
210		};
211	})( $.fn.removeData );
212}
213
214// deprecated
215$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
216
217$.fn.extend({
218	focus: (function( orig ) {
219		return function( delay, fn ) {
220			return typeof delay === "number" ?
221				this.each(function() {
222					var elem = this;
223					setTimeout(function() {
224						$( elem ).focus();
225						if ( fn ) {
226							fn.call( elem );
227						}
228					}, delay );
229				}) :
230				orig.apply( this, arguments );
231		};
232	})( $.fn.focus ),
233
234	disableSelection: (function() {
235		var eventType = "onselectstart" in document.createElement( "div" ) ?
236			"selectstart" :
237			"mousedown";
238
239		return function() {
240			return this.bind( eventType + ".ui-disableSelection", function( event ) {
241				event.preventDefault();
242			});
243		};
244	})(),
245
246	enableSelection: function() {
247		return this.unbind( ".ui-disableSelection" );
248	},
249
250	zIndex: function( zIndex ) {
251		if ( zIndex !== undefined ) {
252			return this.css( "zIndex", zIndex );
253		}
254
255		if ( this.length ) {
256			var elem = $( this[ 0 ] ), position, value;
257			while ( elem.length && elem[ 0 ] !== document ) {
258				// Ignore z-index if position is set to a value where z-index is ignored by the browser
259				// This makes behavior of this function consistent across browsers
260				// WebKit always returns auto if the element is positioned
261				position = elem.css( "position" );
262				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
263					// IE returns 0 when zIndex is not specified
264					// other browsers return a string
265					// we ignore the case of nested elements with an explicit value of 0
266					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
267					value = parseInt( elem.css( "zIndex" ), 10 );
268					if ( !isNaN( value ) && value !== 0 ) {
269						return value;
270					}
271				}
272				elem = elem.parent();
273			}
274		}
275
276		return 0;
277	}
278});
279
280// $.ui.plugin is deprecated. Use $.widget() extensions instead.
281$.ui.plugin = {
282	add: function( module, option, set ) {
283		var i,
284			proto = $.ui[ module ].prototype;
285		for ( i in set ) {
286			proto.plugins[ i ] = proto.plugins[ i ] || [];
287			proto.plugins[ i ].push( [ option, set[ i ] ] );
288		}
289	},
290	call: function( instance, name, args, allowDisconnected ) {
291		var i,
292			set = instance.plugins[ name ];
293
294		if ( !set ) {
295			return;
296		}
297
298		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
299			return;
300		}
301
302		for ( i = 0; i < set.length; i++ ) {
303			if ( instance.options[ set[ i ][ 0 ] ] ) {
304				set[ i ][ 1 ].apply( instance.element, args );
305			}
306		}
307	}
308};
309
310
311/*!
312 * jQuery UI Widget 1.11.4
313 * http://jqueryui.com
314 *
315 * Copyright jQuery Foundation and other contributors
316 * Released under the MIT license.
317 * http://jquery.org/license
318 *
319 * http://api.jqueryui.com/jQuery.widget/
320 */
321
322
323var widget_uuid = 0,
324	widget_slice = Array.prototype.slice;
325
326$.cleanData = (function( orig ) {
327	return function( elems ) {
328		var events, elem, i;
329		for ( i = 0; (elem = elems[i]) != null; i++ ) {
330			try {
331
332				// Only trigger remove when necessary to save time
333				events = $._data( elem, "events" );
334				if ( events && events.remove ) {
335					$( elem ).triggerHandler( "remove" );
336				}
337
338			// http://bugs.jquery.com/ticket/8235
339			} catch ( e ) {}
340		}
341		orig( elems );
342	};
343})( $.cleanData );
344
345$.widget = function( name, base, prototype ) {
346	var fullName, existingConstructor, constructor, basePrototype,
347		// proxiedPrototype allows the provided prototype to remain unmodified
348		// so that it can be used as a mixin for multiple widgets (#8876)
349		proxiedPrototype = {},
350		namespace = name.split( "." )[ 0 ];
351
352	name = name.split( "." )[ 1 ];
353	fullName = namespace + "-" + name;
354
355	if ( !prototype ) {
356		prototype = base;
357		base = $.Widget;
358	}
359
360	// create selector for plugin
361	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
362		return !!$.data( elem, fullName );
363	};
364
365	$[ namespace ] = $[ namespace ] || {};
366	existingConstructor = $[ namespace ][ name ];
367	constructor = $[ namespace ][ name ] = function( options, element ) {
368		// allow instantiation without "new" keyword
369		if ( !this._createWidget ) {
370			return new constructor( options, element );
371		}
372
373		// allow instantiation without initializing for simple inheritance
374		// must use "new" keyword (the code above always passes args)
375		if ( arguments.length ) {
376			this._createWidget( options, element );
377		}
378	};
379	// extend with the existing constructor to carry over any static properties
380	$.extend( constructor, existingConstructor, {
381		version: prototype.version,
382		// copy the object used to create the prototype in case we need to
383		// redefine the widget later
384		_proto: $.extend( {}, prototype ),
385		// track widgets that inherit from this widget in case this widget is
386		// redefined after a widget inherits from it
387		_childConstructors: []
388	});
389
390	basePrototype = new base();
391	// we need to make the options hash a property directly on the new instance
392	// otherwise we'll modify the options hash on the prototype that we're
393	// inheriting from
394	basePrototype.options = $.widget.extend( {}, basePrototype.options );
395	$.each( prototype, function( prop, value ) {
396		if ( !$.isFunction( value ) ) {
397			proxiedPrototype[ prop ] = value;
398			return;
399		}
400		proxiedPrototype[ prop ] = (function() {
401			var _super = function() {
402					return base.prototype[ prop ].apply( this, arguments );
403				},
404				_superApply = function( args ) {
405					return base.prototype[ prop ].apply( this, args );
406				};
407			return function() {
408				var __super = this._super,
409					__superApply = this._superApply,
410					returnValue;
411
412				this._super = _super;
413				this._superApply = _superApply;
414
415				returnValue = value.apply( this, arguments );
416
417				this._super = __super;
418				this._superApply = __superApply;
419
420				return returnValue;
421			};
422		})();
423	});
424	constructor.prototype = $.widget.extend( basePrototype, {
425		// TODO: remove support for widgetEventPrefix
426		// always use the name + a colon as the prefix, e.g., draggable:start
427		// don't prefix for widgets that aren't DOM-based
428		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
429	}, proxiedPrototype, {
430		constructor: constructor,
431		namespace: namespace,
432		widgetName: name,
433		widgetFullName: fullName
434	});
435
436	// If this widget is being redefined then we need to find all widgets that
437	// are inheriting from it and redefine all of them so that they inherit from
438	// the new version of this widget. We're essentially trying to replace one
439	// level in the prototype chain.
440	if ( existingConstructor ) {
441		$.each( existingConstructor._childConstructors, function( i, child ) {
442			var childPrototype = child.prototype;
443
444			// redefine the child widget using the same prototype that was
445			// originally used, but inherit from the new version of the base
446			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
447		});
448		// remove the list of existing child constructors from the old constructor
449		// so the old child constructors can be garbage collected
450		delete existingConstructor._childConstructors;
451	} else {
452		base._childConstructors.push( constructor );
453	}
454
455	$.widget.bridge( name, constructor );
456
457	return constructor;
458};
459
460$.widget.extend = function( target ) {
461	var input = widget_slice.call( arguments, 1 ),
462		inputIndex = 0,
463		inputLength = input.length,
464		key,
465		value;
466	for ( ; inputIndex < inputLength; inputIndex++ ) {
467		for ( key in input[ inputIndex ] ) {
468			value = input[ inputIndex ][ key ];
469			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
470				// Clone objects
471				if ( $.isPlainObject( value ) ) {
472					target[ key ] = $.isPlainObject( target[ key ] ) ?
473						$.widget.extend( {}, target[ key ], value ) :
474						// Don't extend strings, arrays, etc. with objects
475						$.widget.extend( {}, value );
476				// Copy everything else by reference
477				} else {
478					target[ key ] = value;
479				}
480			}
481		}
482	}
483	return target;
484};
485
486$.widget.bridge = function( name, object ) {
487	var fullName = object.prototype.widgetFullName || name;
488	$.fn[ name ] = function( options ) {
489		var isMethodCall = typeof options === "string",
490			args = widget_slice.call( arguments, 1 ),
491			returnValue = this;
492
493		if ( isMethodCall ) {
494			this.each(function() {
495				var methodValue,
496					instance = $.data( this, fullName );
497				if ( options === "instance" ) {
498					returnValue = instance;
499					return false;
500				}
501				if ( !instance ) {
502					return $.error( "cannot call methods on " + name + " prior to initialization; " +
503						"attempted to call method '" + options + "'" );
504				}
505				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
506					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
507				}
508				methodValue = instance[ options ].apply( instance, args );
509				if ( methodValue !== instance && methodValue !== undefined ) {
510					returnValue = methodValue && methodValue.jquery ?
511						returnValue.pushStack( methodValue.get() ) :
512						methodValue;
513					return false;
514				}
515			});
516		} else {
517
518			// Allow multiple hashes to be passed on init
519			if ( args.length ) {
520				options = $.widget.extend.apply( null, [ options ].concat(args) );
521			}
522
523			this.each(function() {
524				var instance = $.data( this, fullName );
525				if ( instance ) {
526					instance.option( options || {} );
527					if ( instance._init ) {
528						instance._init();
529					}
530				} else {
531					$.data( this, fullName, new object( options, this ) );
532				}
533			});
534		}
535
536		return returnValue;
537	};
538};
539
540$.Widget = function( /* options, element */ ) {};
541$.Widget._childConstructors = [];
542
543$.Widget.prototype = {
544	widgetName: "widget",
545	widgetEventPrefix: "",
546	defaultElement: "<div>",
547	options: {
548		disabled: false,
549
550		// callbacks
551		create: null
552	},
553	_createWidget: function( options, element ) {
554		element = $( element || this.defaultElement || this )[ 0 ];
555		this.element = $( element );
556		this.uuid = widget_uuid++;
557		this.eventNamespace = "." + this.widgetName + this.uuid;
558
559		this.bindings = $();
560		this.hoverable = $();
561		this.focusable = $();
562
563		if ( element !== this ) {
564			$.data( element, this.widgetFullName, this );
565			this._on( true, this.element, {
566				remove: function( event ) {
567					if ( event.target === element ) {
568						this.destroy();
569					}
570				}
571			});
572			this.document = $( element.style ?
573				// element within the document
574				element.ownerDocument :
575				// element is window or document
576				element.document || element );
577			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
578		}
579
580		this.options = $.widget.extend( {},
581			this.options,
582			this._getCreateOptions(),
583			options );
584
585		this._create();
586		this._trigger( "create", null, this._getCreateEventData() );
587		this._init();
588	},
589	_getCreateOptions: $.noop,
590	_getCreateEventData: $.noop,
591	_create: $.noop,
592	_init: $.noop,
593
594	destroy: function() {
595		this._destroy();
596		// we can probably remove the unbind calls in 2.0
597		// all event bindings should go through this._on()
598		this.element
599			.unbind( this.eventNamespace )
600			.removeData( this.widgetFullName )
601			// support: jquery <1.6.3
602			// http://bugs.jquery.com/ticket/9413
603			.removeData( $.camelCase( this.widgetFullName ) );
604		this.widget()
605			.unbind( this.eventNamespace )
606			.removeAttr( "aria-disabled" )
607			.removeClass(
608				this.widgetFullName + "-disabled " +
609				"ui-state-disabled" );
610
611		// clean up events and states
612		this.bindings.unbind( this.eventNamespace );
613		this.hoverable.removeClass( "ui-state-hover" );
614		this.focusable.removeClass( "ui-state-focus" );
615	},
616	_destroy: $.noop,
617
618	widget: function() {
619		return this.element;
620	},
621
622	option: function( key, value ) {
623		var options = key,
624			parts,
625			curOption,
626			i;
627
628		if ( arguments.length === 0 ) {
629			// don't return a reference to the internal hash
630			return $.widget.extend( {}, this.options );
631		}
632
633		if ( typeof key === "string" ) {
634			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
635			options = {};
636			parts = key.split( "." );
637			key = parts.shift();
638			if ( parts.length ) {
639				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
640				for ( i = 0; i < parts.length - 1; i++ ) {
641					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
642					curOption = curOption[ parts[ i ] ];
643				}
644				key = parts.pop();
645				if ( arguments.length === 1 ) {
646					return curOption[ key ] === undefined ? null : curOption[ key ];
647				}
648				curOption[ key ] = value;
649			} else {
650				if ( arguments.length === 1 ) {
651					return this.options[ key ] === undefined ? null : this.options[ key ];
652				}
653				options[ key ] = value;
654			}
655		}
656
657		this._setOptions( options );
658
659		return this;
660	},
661	_setOptions: function( options ) {
662		var key;
663
664		for ( key in options ) {
665			this._setOption( key, options[ key ] );
666		}
667
668		return this;
669	},
670	_setOption: function( key, value ) {
671		this.options[ key ] = value;
672
673		if ( key === "disabled" ) {
674			this.widget()
675				.toggleClass( this.widgetFullName + "-disabled", !!value );
676
677			// If the widget is becoming disabled, then nothing is interactive
678			if ( value ) {
679				this.hoverable.removeClass( "ui-state-hover" );
680				this.focusable.removeClass( "ui-state-focus" );
681			}
682		}
683
684		return this;
685	},
686
687	enable: function() {
688		return this._setOptions({ disabled: false });
689	},
690	disable: function() {
691		return this._setOptions({ disabled: true });
692	},
693
694	_on: function( suppressDisabledCheck, element, handlers ) {
695		var delegateElement,
696			instance = this;
697
698		// no suppressDisabledCheck flag, shuffle arguments
699		if ( typeof suppressDisabledCheck !== "boolean" ) {
700			handlers = element;
701			element = suppressDisabledCheck;
702			suppressDisabledCheck = false;
703		}
704
705		// no element argument, shuffle and use this.element
706		if ( !handlers ) {
707			handlers = element;
708			element = this.element;
709			delegateElement = this.widget();
710		} else {
711			element = delegateElement = $( element );
712			this.bindings = this.bindings.add( element );
713		}
714
715		$.each( handlers, function( event, handler ) {
716			function handlerProxy() {
717				// allow widgets to customize the disabled handling
718				// - disabled as an array instead of boolean
719				// - disabled class as method for disabling individual parts
720				if ( !suppressDisabledCheck &&
721						( instance.options.disabled === true ||
722							$( this ).hasClass( "ui-state-disabled" ) ) ) {
723					return;
724				}
725				return ( typeof handler === "string" ? instance[ handler ] : handler )
726					.apply( instance, arguments );
727			}
728
729			// copy the guid so direct unbinding works
730			if ( typeof handler !== "string" ) {
731				handlerProxy.guid = handler.guid =
732					handler.guid || handlerProxy.guid || $.guid++;
733			}
734
735			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
736				eventName = match[1] + instance.eventNamespace,
737				selector = match[2];
738			if ( selector ) {
739				delegateElement.delegate( selector, eventName, handlerProxy );
740			} else {
741				element.bind( eventName, handlerProxy );
742			}
743		});
744	},
745
746	_off: function( element, eventName ) {
747		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
748			this.eventNamespace;
749		element.unbind( eventName ).undelegate( eventName );
750
751		// Clear the stack to avoid memory leaks (#10056)
752		this.bindings = $( this.bindings.not( element ).get() );
753		this.focusable = $( this.focusable.not( element ).get() );
754		this.hoverable = $( this.hoverable.not( element ).get() );
755	},
756
757	_delay: function( handler, delay ) {
758		function handlerProxy() {
759			return ( typeof handler === "string" ? instance[ handler ] : handler )
760				.apply( instance, arguments );
761		}
762		var instance = this;
763		return setTimeout( handlerProxy, delay || 0 );
764	},
765
766	_hoverable: function( element ) {
767		this.hoverable = this.hoverable.add( element );
768		this._on( element, {
769			mouseenter: function( event ) {
770				$( event.currentTarget ).addClass( "ui-state-hover" );
771			},
772			mouseleave: function( event ) {
773				$( event.currentTarget ).removeClass( "ui-state-hover" );
774			}
775		});
776	},
777
778	_focusable: function( element ) {
779		this.focusable = this.focusable.add( element );
780		this._on( element, {
781			focusin: function( event ) {
782				$( event.currentTarget ).addClass( "ui-state-focus" );
783			},
784			focusout: function( event ) {
785				$( event.currentTarget ).removeClass( "ui-state-focus" );
786			}
787		});
788	},
789
790	_trigger: function( type, event, data ) {
791		var prop, orig,
792			callback = this.options[ type ];
793
794		data = data || {};
795		event = $.Event( event );
796		event.type = ( type === this.widgetEventPrefix ?
797			type :
798			this.widgetEventPrefix + type ).toLowerCase();
799		// the original event may come from any element
800		// so we need to reset the target on the new event
801		event.target = this.element[ 0 ];
802
803		// copy original event properties over to the new event
804		orig = event.originalEvent;
805		if ( orig ) {
806			for ( prop in orig ) {
807				if ( !( prop in event ) ) {
808					event[ prop ] = orig[ prop ];
809				}
810			}
811		}
812
813		this.element.trigger( event, data );
814		return !( $.isFunction( callback ) &&
815			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
816			event.isDefaultPrevented() );
817	}
818};
819
820$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
821	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
822		if ( typeof options === "string" ) {
823			options = { effect: options };
824		}
825		var hasOptions,
826			effectName = !options ?
827				method :
828				options === true || typeof options === "number" ?
829					defaultEffect :
830					options.effect || defaultEffect;
831		options = options || {};
832		if ( typeof options === "number" ) {
833			options = { duration: options };
834		}
835		hasOptions = !$.isEmptyObject( options );
836		options.complete = callback;
837		if ( options.delay ) {
838			element.delay( options.delay );
839		}
840		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
841			element[ method ]( options );
842		} else if ( effectName !== method && element[ effectName ] ) {
843			element[ effectName ]( options.duration, options.easing, callback );
844		} else {
845			element.queue(function( next ) {
846				$( this )[ method ]();
847				if ( callback ) {
848					callback.call( element[ 0 ] );
849				}
850				next();
851			});
852		}
853	};
854});
855
856var widget = $.widget;
857
858
859/*!
860 * jQuery UI Mouse 1.11.4
861 * http://jqueryui.com
862 *
863 * Copyright jQuery Foundation and other contributors
864 * Released under the MIT license.
865 * http://jquery.org/license
866 *
867 * http://api.jqueryui.com/mouse/
868 */
869
870
871var mouseHandled = false;
872$( document ).mouseup( function() {
873	mouseHandled = false;
874});
875
876var mouse = $.widget("ui.mouse", {
877	version: "1.11.4",
878	options: {
879		cancel: "input,textarea,button,select,option",
880		distance: 1,
881		delay: 0
882	},
883	_mouseInit: function() {
884		var that = this;
885
886		this.element
887			.bind("mousedown." + this.widgetName, function(event) {
888				return that._mouseDown(event);
889			})
890			.bind("click." + this.widgetName, function(event) {
891				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
892					$.removeData(event.target, that.widgetName + ".preventClickEvent");
893					event.stopImmediatePropagation();
894					return false;
895				}
896			});
897
898		this.started = false;
899	},
900
901	// TODO: make sure destroying one instance of mouse doesn't mess with
902	// other instances of mouse
903	_mouseDestroy: function() {
904		this.element.unbind("." + this.widgetName);
905		if ( this._mouseMoveDelegate ) {
906			this.document
907				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
908				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
909		}
910	},
911
912	_mouseDown: function(event) {
913		// don't let more than one widget handle mouseStart
914		if ( mouseHandled ) {
915			return;
916		}
917
918		this._mouseMoved = false;
919
920		// we may have missed mouseup (out of window)
921		(this._mouseStarted && this._mouseUp(event));
922
923		this._mouseDownEvent = event;
924
925		var that = this,
926			btnIsLeft = (event.which === 1),
927			// event.target.nodeName works around a bug in IE 8 with
928			// disabled inputs (#7620)
929			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
930		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
931			return true;
932		}
933
934		this.mouseDelayMet = !this.options.delay;
935		if (!this.mouseDelayMet) {
936			this._mouseDelayTimer = setTimeout(function() {
937				that.mouseDelayMet = true;
938			}, this.options.delay);
939		}
940
941		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
942			this._mouseStarted = (this._mouseStart(event) !== false);
943			if (!this._mouseStarted) {
944				event.preventDefault();
945				return true;
946			}
947		}
948
949		// Click event may never have fired (Gecko & Opera)
950		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
951			$.removeData(event.target, this.widgetName + ".preventClickEvent");
952		}
953
954		// these delegates are required to keep context
955		this._mouseMoveDelegate = function(event) {
956			return that._mouseMove(event);
957		};
958		this._mouseUpDelegate = function(event) {
959			return that._mouseUp(event);
960		};
961
962		this.document
963			.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
964			.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
965
966		event.preventDefault();
967
968		mouseHandled = true;
969		return true;
970	},
971
972	_mouseMove: function(event) {
973		// Only check for mouseups outside the document if you've moved inside the document
974		// at least once. This prevents the firing of mouseup in the case of IE<9, which will
975		// fire a mousemove event if content is placed under the cursor. See #7778
976		// Support: IE <9
977		if ( this._mouseMoved ) {
978			// IE mouseup check - mouseup happened when mouse was out of window
979			if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
980				return this._mouseUp(event);
981
982			// Iframe mouseup check - mouseup occurred in another document
983			} else if ( !event.which ) {
984				return this._mouseUp( event );
985			}
986		}
987
988		if ( event.which || event.button ) {
989			this._mouseMoved = true;
990		}
991
992		if (this._mouseStarted) {
993			this._mouseDrag(event);
994			return event.preventDefault();
995		}
996
997		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
998			this._mouseStarted =
999				(this._mouseStart(this._mouseDownEvent, event) !== false);
1000			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1001		}
1002
1003		return !this._mouseStarted;
1004	},
1005
1006	_mouseUp: function(event) {
1007		this.document
1008			.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1009			.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1010
1011		if (this._mouseStarted) {
1012			this._mouseStarted = false;
1013
1014			if (event.target === this._mouseDownEvent.target) {
1015				$.data(event.target, this.widgetName + ".preventClickEvent", true);
1016			}
1017
1018			this._mouseStop(event);
1019		}
1020
1021		mouseHandled = false;
1022		return false;
1023	},
1024
1025	_mouseDistanceMet: function(event) {
1026		return (Math.max(
1027				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1028				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1029			) >= this.options.distance
1030		);
1031	},
1032
1033	_mouseDelayMet: function(/* event */) {
1034		return this.mouseDelayMet;
1035	},
1036
1037	// These are placeholder methods, to be overriden by extending plugin
1038	_mouseStart: function(/* event */) {},
1039	_mouseDrag: function(/* event */) {},
1040	_mouseStop: function(/* event */) {},
1041	_mouseCapture: function(/* event */) { return true; }
1042});
1043
1044
1045/*!
1046 * jQuery UI Position 1.11.4
1047 * http://jqueryui.com
1048 *
1049 * Copyright jQuery Foundation and other contributors
1050 * Released under the MIT license.
1051 * http://jquery.org/license
1052 *
1053 * http://api.jqueryui.com/position/
1054 */
1055
1056(function() {
1057
1058$.ui = $.ui || {};
1059
1060var cachedScrollbarWidth, supportsOffsetFractions,
1061	max = Math.max,
1062	abs = Math.abs,
1063	round = Math.round,
1064	rhorizontal = /left|center|right/,
1065	rvertical = /top|center|bottom/,
1066	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1067	rposition = /^\w+/,
1068	rpercent = /%$/,
1069	_position = $.fn.position;
1070
1071function getOffsets( offsets, width, height ) {
1072	return [
1073		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1074		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1075	];
1076}
1077
1078function parseCss( element, property ) {
1079	return parseInt( $.css( element, property ), 10 ) || 0;
1080}
1081
1082function getDimensions( elem ) {
1083	var raw = elem[0];
1084	if ( raw.nodeType === 9 ) {
1085		return {
1086			width: elem.width(),
1087			height: elem.height(),
1088			offset: { top: 0, left: 0 }
1089		};
1090	}
1091	if ( $.isWindow( raw ) ) {
1092		return {
1093			width: elem.width(),
1094			height: elem.height(),
1095			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1096		};
1097	}
1098	if ( raw.preventDefault ) {
1099		return {
1100			width: 0,
1101			height: 0,
1102			offset: { top: raw.pageY, left: raw.pageX }
1103		};
1104	}
1105	return {
1106		width: elem.outerWidth(),
1107		height: elem.outerHeight(),
1108		offset: elem.offset()
1109	};
1110}
1111
1112$.position = {
1113	scrollbarWidth: function() {
1114		if ( cachedScrollbarWidth !== undefined ) {
1115			return cachedScrollbarWidth;
1116		}
1117		var w1, w2,
1118			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1119			innerDiv = div.children()[0];
1120
1121		$( "body" ).append( div );
1122		w1 = innerDiv.offsetWidth;
1123		div.css( "overflow", "scroll" );
1124
1125		w2 = innerDiv.offsetWidth;
1126
1127		if ( w1 === w2 ) {
1128			w2 = div[0].clientWidth;
1129		}
1130
1131		div.remove();
1132
1133		return (cachedScrollbarWidth = w1 - w2);
1134	},
1135	getScrollInfo: function( within ) {
1136		var overflowX = within.isWindow || within.isDocument ? "" :
1137				within.element.css( "overflow-x" ),
1138			overflowY = within.isWindow || within.isDocument ? "" :
1139				within.element.css( "overflow-y" ),
1140			hasOverflowX = overflowX === "scroll" ||
1141				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1142			hasOverflowY = overflowY === "scroll" ||
1143				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1144		return {
1145			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1146			height: hasOverflowX ? $.position.scrollbarWidth() : 0
1147		};
1148	},
1149	getWithinInfo: function( element ) {
1150		var withinElement = $( element || window ),
1151			isWindow = $.isWindow( withinElement[0] ),
1152			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1153		return {
1154			element: withinElement,
1155			isWindow: isWindow,
1156			isDocument: isDocument,
1157			offset: withinElement.offset() || { left: 0, top: 0 },
1158			scrollLeft: withinElement.scrollLeft(),
1159			scrollTop: withinElement.scrollTop(),
1160
1161			// support: jQuery 1.6.x
1162			// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1163			width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1164			height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1165		};
1166	}
1167};
1168
1169$.fn.position = function( options ) {
1170	if ( !options || !options.of ) {
1171		return _position.apply( this, arguments );
1172	}
1173
1174	// make a copy, we don't want to modify arguments
1175	options = $.extend( {}, options );
1176
1177	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1178		target = $( options.of ),
1179		within = $.position.getWithinInfo( options.within ),
1180		scrollInfo = $.position.getScrollInfo( within ),
1181		collision = ( options.collision || "flip" ).split( " " ),
1182		offsets = {};
1183
1184	dimensions = getDimensions( target );
1185	if ( target[0].preventDefault ) {
1186		// force left top to allow flipping
1187		options.at = "left top";
1188	}
1189	targetWidth = dimensions.width;
1190	targetHeight = dimensions.height;
1191	targetOffset = dimensions.offset;
1192	// clone to reuse original targetOffset later
1193	basePosition = $.extend( {}, targetOffset );
1194
1195	// force my and at to have valid horizontal and vertical positions
1196	// if a value is missing or invalid, it will be converted to center
1197	$.each( [ "my", "at" ], function() {
1198		var pos = ( options[ this ] || "" ).split( " " ),
1199			horizontalOffset,
1200			verticalOffset;
1201
1202		if ( pos.length === 1) {
1203			pos = rhorizontal.test( pos[ 0 ] ) ?

1204				pos.concat( [ "center" ] ) :
1205				rvertical.test( pos[ 0 ] ) ?
1206					[ "center" ].concat( pos ) :
1207					[ "center", "center" ];
1208		}
1209		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1210		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1211
1212		// calculate offsets
1213		horizontalOffset = roffset.exec( pos[ 0 ] );
1214		verticalOffset = roffset.exec( pos[ 1 ] );
1215		offsets[ this ] = [
1216			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1217			verticalOffset ? verticalOffset[ 0 ] : 0
1218		];
1219
1220		// reduce to just the positions without the offsets
1221		options[ this ] = [
1222			rposition.exec( pos[ 0 ] )[ 0 ],
1223			rposition.exec( pos[ 1 ] )[ 0 ]
1224		];
1225	});
1226
1227	// normalize collision option
1228	if ( collision.length === 1 ) {
1229		collision[ 1 ] = collision[ 0 ];
1230	}
1231
1232	if ( options.at[ 0 ] === "right" ) {
1233		basePosition.left += targetWidth;
1234	} else if ( options.at[ 0 ] === "center" ) {
1235		basePosition.left += targetWidth / 2;
1236	}
1237
1238	if ( options.at[ 1 ] === "bottom" ) {
1239		basePosition.top += targetHeight;
1240	} else if ( options.at[ 1 ] === "center" ) {
1241		basePosition.top += targetHeight / 2;
1242	}
1243
1244	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1245	basePosition.left += atOffset[ 0 ];
1246	basePosition.top += atOffset[ 1 ];
1247
1248	return this.each(function() {
1249		var collisionPosition, using,
1250			elem = $( this ),
1251			elemWidth = elem.outerWidth(),
1252			elemHeight = elem.outerHeight(),
1253			marginLeft = parseCss( this, "marginLeft" ),
1254			marginTop = parseCss( this, "marginTop" ),
1255			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1256			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1257			position = $.extend( {}, basePosition ),
1258			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1259
1260		if ( options.my[ 0 ] === "right" ) {
1261			position.left -= elemWidth;
1262		} else if ( options.my[ 0 ] === "center" ) {
1263			position.left -= elemWidth / 2;
1264		}
1265
1266		if ( options.my[ 1 ] === "bottom" ) {
1267			position.top -= elemHeight;
1268		} else if ( options.my[ 1 ] === "center" ) {
1269			position.top -= elemHeight / 2;
1270		}
1271
1272		position.left += myOffset[ 0 ];
1273		position.top += myOffset[ 1 ];
1274
1275		// if the browser doesn't support fractions, then round for consistent results
1276		if ( !supportsOffsetFractions ) {
1277			position.left = round( position.left );
1278			position.top = round( position.top );
1279		}
1280
1281		collisionPosition = {
1282			marginLeft: marginLeft,
1283			marginTop: marginTop
1284		};
1285
1286		$.each( [ "left", "top" ], function( i, dir ) {
1287			if ( $.ui.position[ collision[ i ] ] ) {
1288				$.ui.position[ collision[ i ] ][ dir ]( position, {
1289					targetWidth: targetWidth,
1290					targetHeight: targetHeight,
1291					elemWidth: elemWidth,
1292					elemHeight: elemHeight,
1293					collisionPosition: collisionPosition,
1294					collisionWidth: collisionWidth,
1295					collisionHeight: collisionHeight,
1296					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1297					my: options.my,
1298					at: options.at,
1299					within: within,
1300					elem: elem
1301				});
1302			}
1303		});
1304
1305		if ( options.using ) {
1306			// adds feedback as second argument to using callback, if present
1307			using = function( props ) {
1308				var left = targetOffset.left - position.left,
1309					right = left + targetWidth - elemWidth,
1310					top = targetOffset.top - position.top,
1311					bottom = top + targetHeight - elemHeight,
1312					feedback = {
1313						target: {
1314							element: target,
1315							left: targetOffset.left,
1316							top: targetOffset.top,
1317							width: targetWidth,
1318							height: targetHeight
1319						},
1320						element: {
1321							element: elem,
1322							left: position.left,
1323							top: position.top,
1324							width: elemWidth,
1325							height: elemHeight
1326						},
1327						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1328						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1329					};
1330				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1331					feedback.horizontal = "center";
1332				}
1333				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1334					feedback.vertical = "middle";
1335				}
1336				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1337					feedback.important = "horizontal";
1338				} else {
1339					feedback.important = "vertical";
1340				}
1341				options.using.call( this, props, feedback );
1342			};
1343		}
1344
1345		elem.offset( $.extend( position, { using: using } ) );
1346	});
1347};
1348
1349$.ui.position = {
1350	fit: {
1351		left: function( position, data ) {
1352			var within = data.within,
1353				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1354				outerWidth = within.width,
1355				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1356				overLeft = withinOffset - collisionPosLeft,
1357				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1358				newOverRight;
1359

1360			// element is wider than within
1361			if ( data.collisionWidth > outerWidth ) {
1362				// element is initially over the left side of within
1363				if ( overLeft > 0 && overRight <= 0 ) {
1364					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1365					position.left += overLeft - newOverRight;
1366				// element is initially over right side of within
1367				} else if ( overRight > 0 && overLeft <= 0 ) {
1368					position.left = withinOffset;
1369				// element is initially over both left and right sides of within
1370				} else {
1371					if ( overLeft > overRight ) {
1372						position.left = withinOffset + outerWidth - data.collisionWidth;
1373					} else {
1374						position.left = withinOffset;
1375					}
1376				}
1377			// too far left -> align with left edge
1378			} else if ( overLeft > 0 ) {
1379				position.left += overLeft;
1380			// too far right -> align with right edge
1381			} else if ( overRight > 0 ) {
1382				position.left -= overRight;
1383			// adjust based on position and margin
1384			} else {
1385				position.left = max( position.left - collisionPosLeft, position.left );
1386			}
1387		},
1388		top: function( position, data ) {
1389			var within = data.within,
1390				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1391				outerHeight = data.within.height,
1392				collisionPosTop = position.top - data.collisionPosition.marginTop,
1393				overTop = withinOffset - collisionPosTop,
1394				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1395				newOverBottom;
1396
1397			// element is taller than within
1398			if ( data.collisionHeight > outerHeight ) {
1399				// element is initially over the top of within
1400				if ( overTop > 0 && overBottom <= 0 ) {
1401					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1402					position.top += overTop - newOverBottom;
1403				// element is initially over bottom of within
1404				} else if ( overBottom > 0 && overTop <= 0 ) {
1405					position.top = withinOffset;
1406				// element is initially over both top and bottom of within
1407				} else {
1408					if ( overTop > overBottom ) {
1409						position.top = withinOffset + outerHeight - data.collisionHeight;
1410					} else {
1411						position.top = withinOffset;
1412					}
1413				}
1414			// too far up -> align with top
1415			} else if ( overTop > 0 ) {
1416				position.top += overTop;
1417			// too far down -> align with bottom edge
1418			} else if ( overBottom > 0 ) {
1419				position.top -= overBottom;
1420			// adjust based on position and margin
1421			} else {
1422				position.top = max( position.top - collisionPosTop, position.top );
1423			}
1424		}
1425	},
1426	flip: {
1427		left: function( position, data ) {
1428			var within = data.within,
1429				withinOffset = within.offset.left + within.scrollLeft,
1430				outerWidth = within.width,
1431				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1432				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1433				overLeft = collisionPosLeft - offsetLeft,
1434				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1435				myOffset = data.my[ 0 ] === "left" ?
1436					-data.elemWidth :
1437					data.my[ 0 ] === "right" ?
1438						data.elemWidth :
1439						0,
1440				atOffset = data.at[ 0 ] === "left" ?
1441					data.targetWidth :
1442					data.at[ 0 ] === "right" ?
1443						-data.targetWidth :
1444						0,
1445				offset = -2 * data.offset[ 0 ],
1446				newOverRight,
1447				newOverLeft;
1448
1449			if ( overLeft < 0 ) {
1450				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1451				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1452					position.left += myOffset + atOffset + offset;
1453				}
1454			} else if ( overRight > 0 ) {
1455				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1456				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1457					position.left += myOffset + atOffset + offset;
1458				}
1459			}
1460		},
1461		top: function( position, data ) {
1462			var within = data.within,
1463				withinOffset = within.offset.top + within.scrollTop,
1464				outerHeight = within.height,
1465				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1466				collisionPosTop = position.top - data.collisionPosition.marginTop,
1467				overTop = collisionPosTop - offsetTop,
1468				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1469				top = data.my[ 1 ] === "top",
1470				myOffset = top ?
1471					-data.elemHeight :
1472					data.my[ 1 ] === "bottom" ?
1473						data.elemHeight :
1474						0,
1475				atOffset = data.at[ 1 ] === "top" ?
1476					data.targetHeight :
1477					data.at[ 1 ] === "bottom" ?
1478						-data.targetHeight :
1479						0,
1480				offset = -2 * data.offset[ 1 ],
1481				newOverTop,
1482				newOverBottom;
1483			if ( overTop < 0 ) {
1484				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1485				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1486					position.top += myOffset + atOffset + offset;
1487				}
1488			} else if ( overBottom > 0 ) {
1489				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1490				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1491					position.top += myOffset + atOffset + offset;
1492				}
1493			}
1494		}
1495	},
1496	flipfit: {
1497		left: function() {
1498			$.ui.position.flip.left.apply( this, arguments );
1499			$.ui.position.fit.left.apply( this, arguments );
1500		},
1501		top: function() {
1502			$.ui.position.flip.top.apply( this, arguments );
1503			$.ui.position.fit.top.apply( this, arguments );
1504		}
1505	}
1506};
1507
1508// fraction support test
1509(function() {
1510	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1511		body = document.getElementsByTagName( "body" )[ 0 ],
1512		div = document.createElement( "div" );
1513
1514	//Create a "fake body" for testing based on method used in jQuery.support
1515	testElement = document.createElement( body ? "div" : "body" );
1516	testElementStyle = {
1517		visibility: "hidden",
1518		width: 0,
1519		height: 0,
1520		border: 0,
1521		margin: 0,
1522		background: "none"
1523	};
1524	if ( body ) {
1525		$.extend( testElementStyle, {
1526			position: "absolute",
1527			left: "-1000px",
1528			top: "-1000px"
1529		});
1530	}
1531	for ( i in testElementStyle ) {
1532		testElement.style[ i ] = testElementStyle[ i ];
1533	}
1534	testElement.appendChild( div );
1535	testElementParent = body || document.documentElement;
1536	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1537
1538	div.style.cssText = "position: absolute; left: 10.7432222px;";
1539
1540	offsetLeft = $( div ).offset().left;
1541	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1542
1543	testElement.innerHTML = "";
1544	testElementParent.removeChild( testElement );
1545})();
1546
1547})();
1548
1549var position = $.ui.position;
1550
1551
1552/*!
1553 * jQuery UI Accordion 1.11.4
1554 * http://jqueryui.com
1555 *
1556 * Copyright jQuery Foundation and other contributors
1557 * Released under the MIT license.
1558 * http://jquery.org/license
1559 *
1560 * http://api.jqueryui.com/accordion/
1561 */
1562
1563
1564var accordion = $.widget( "ui.accordion", {
1565	version: "1.11.4",
1566	options: {
1567		active: 0,
1568		animate: {},
1569		collapsible: false,
1570		event: "click",
1571		header: "> li > :first-child,> :not(li):even",
1572		heightStyle: "auto",
1573		icons: {
1574			activeHeader: "ui-icon-triangle-1-s",
1575			header: "ui-icon-triangle-1-e"
1576		},
1577
1578		// callbacks
1579		activate: null,
1580		beforeActivate: null
1581	},
1582
1583	hideProps: {
1584		borderTopWidth: "hide",
1585		borderBottomWidth: "hide",
1586		paddingTop: "hide",
1587		paddingBottom: "hide",
1588		height: "hide"
1589	},
1590
1591	showProps: {
1592		borderTopWidth: "show",

1593		borderBottomWidth: "show",
1594		paddingTop: "show",
1595		paddingBottom: "show",
1596		height: "show"
1597	},
1598
1599	_create: function() {
1600		var options = this.options;
1601		this.prevShow = this.prevHide = $();
1602		this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1603			// ARIA
1604			.attr( "role", "tablist" );
1605
1606		// don't allow collapsible: false and active: false / null
1607		if ( !options.collapsible && (options.active === false || options.active == null) ) {
1608			options.active = 0;
1609		}
1610
1611		this._processPanels();
1612		// handle negative values
1613		if ( options.active < 0 ) {
1614			options.active += this.headers.length;
1615		}
1616		this._refresh();
1617	},
1618
1619	_getCreateEventData: function() {
1620		return {
1621			header: this.active,
1622			panel: !this.active.length ? $() : this.active.next()
1623		};
1624	},
1625
1626	_createIcons: function() {
1627		var icons = this.options.icons;
1628		if ( icons ) {
1629			$( "<span>" )
1630				.addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1631				.prependTo( this.headers );
1632			this.active.children( ".ui-accordion-header-icon" )
1633				.removeClass( icons.header )
1634				.addClass( icons.activeHeader );
1635			this.headers.addClass( "ui-accordion-icons" );
1636		}
1637	},
1638
1639	_destroyIcons: function() {
1640		this.headers
1641			.removeClass( "ui-accordion-icons" )
1642			.children( ".ui-accordion-header-icon" )
1643				.remove();
1644	},
1645
1646	_destroy: function() {
1647		var contents;
1648
1649		// clean up main element
1650		this.element
1651			.removeClass( "ui-accordion ui-widget ui-helper-reset" )
1652			.removeAttr( "role" );
1653
1654		// clean up headers
1655		this.headers
1656			.removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1657				"ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1658			.removeAttr( "role" )
1659			.removeAttr( "aria-expanded" )
1660			.removeAttr( "aria-selected" )
1661			.removeAttr( "aria-controls" )
1662			.removeAttr( "tabIndex" )
1663			.removeUniqueId();
1664
1665		this._destroyIcons();
1666
1667		// clean up content panels
1668		contents = this.headers.next()
1669			.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1670				"ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1671			.css( "display", "" )
1672			.removeAttr( "role" )
1673			.removeAttr( "aria-hidden" )
1674			.removeAttr( "aria-labelledby" )
1675			.removeUniqueId();
1676
1677		if ( this.options.heightStyle !== "content" ) {
1678			contents.css( "height", "" );
1679		}
1680	},
1681
1682	_setOption: function( key, value ) {
1683		if ( key === "active" ) {
1684			// _activate() will handle invalid values and update this.options
1685			this._activate( value );
1686			return;
1687		}
1688
1689		if ( key === "event" ) {
1690			if ( this.options.event ) {
1691				this._off( this.headers, this.options.event );
1692			}
1693			this._setupEvents( value );
1694		}
1695
1696		this._super( key, value );
1697
1698		// setting collapsible: false while collapsed; open first panel
1699		if ( key === "collapsible" && !value && this.options.active === false ) {
1700			this._activate( 0 );
1701		}
1702
1703		if ( key === "icons" ) {
1704			this._destroyIcons();
1705			if ( value ) {
1706				this._createIcons();
1707			}
1708		}
1709
1710		// #5332 - opacity doesn't cascade to positioned elements in IE
1711		// so we need to add the disabled class to the headers and panels
1712		if ( key === "disabled" ) {
1713			this.element
1714				.toggleClass( "ui-state-disabled", !!value )
1715				.attr( "aria-disabled", value );
1716			this.headers.add( this.headers.next() )
1717				.toggleClass( "ui-state-disabled", !!value );
1718		}
1719	},
1720
1721	_keydown: function( event ) {
1722		if ( event.altKey || event.ctrlKey ) {
1723			return;
1724		}
1725
1726		var keyCode = $.ui.keyCode,
1727			length = this.headers.length,
1728			currentIndex = this.headers.index( event.target ),
1729			toFocus = false;
1730
1731		switch ( event.keyCode ) {
1732			case keyCode.RIGHT:
1733			case keyCode.DOWN:
1734				toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1735				break;
1736			case keyCode.LEFT:
1737			case keyCode.UP:
1738				toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1739				break;
1740			case keyCode.SPACE:
1741			case keyCode.ENTER:
1742				this._eventHandler( event );
1743				break;
1744			case keyCode.HOME:
1745				toFocus = this.headers[ 0 ];
1746				break;
1747			case keyCode.END:
1748				toFocus = this.headers[ length - 1 ];
1749				break;
1750		}
1751
1752		if ( toFocus ) {
1753			$( event.target ).attr( "tabIndex", -1 );
1754			$( toFocus ).attr( "tabIndex", 0 );
1755			toFocus.focus();
1756			event.preventDefault();
1757		}
1758	},
1759
1760	_panelKeyDown: function( event ) {
1761		if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1762			$( event.currentTarget ).prev().focus();
1763		}
1764	},
1765
1766	refresh: function() {
1767		var options = this.options;
1768		this._processPanels();
1769

1770		// was collapsed or no panel
1771		if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1772			options.active = false;
1773			this.active = $();
1774		// active false only when collapsible is true
1775		} else if ( options.active === false ) {
1776			this._activate( 0 );
1777		// was active, but active panel is gone
1778		} else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1779			// all remaining panel are disabled
1780			if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1781				options.active = false;
1782				this.active = $();
1783			// activate previous panel
1784			} else {
1785				this._activate( Math.max( 0, options.active - 1 ) );
1786			}
1787		// was active, active panel still exists
1788		} else {
1789			// make sure active index is correct
1790			options.active = this.headers.index( this.active );
1791		}
1792
1793		this._destroyIcons();
1794
1795		this._refresh();
1796	},
1797
1798	_processPanels: function() {
1799		var prevHeaders = this.headers,
1800			prevPanels = this.panels;
1801
1802		this.headers = this.element.find( this.options.header )
1803			.addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1804
1805		this.panels = this.headers.next()
1806			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1807			.filter( ":not(.ui-accordion-content-active)" )
1808			.hide();
1809
1810		// Avoid memory leaks (#10056)
1811		if ( prevPanels ) {
1812			this._off( prevHeaders.not( this.headers ) );
1813			this._off( prevPanels.not( this.panels ) );
1814		}
1815	},
1816
1817	_refresh: function() {
1818		var maxHeight,
1819			options = this.options,
1820			heightStyle = options.heightStyle,
1821			parent = this.element.parent();
1822
1823		this.active = this._findActive( options.active )
1824			.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1825			.removeClass( "ui-corner-all" );
1826		this.active.next()
1827			.addClass( "ui-accordion-content-active" )
1828			.show();
1829
1830		this.headers
1831			.attr( "role", "tab" )
1832			.each(function() {
1833				var header = $( this ),
1834					headerId = header.uniqueId().attr( "id" ),
1835					panel = header.next(),
1836					panelId = panel.uniqueId().attr( "id" );
1837				header.attr( "aria-controls", panelId );
1838				panel.attr( "aria-labelledby", headerId );
1839			})
1840			.next()
1841				.attr( "role", "tabpanel" );
1842
1843		this.headers
1844			.not( this.active )
1845			.attr({
1846				"aria-selected": "false",
1847				"aria-expanded": "false",
1848				tabIndex: -1
1849			})
1850			.next()
1851				.attr({
1852					"aria-hidden": "true"
1853				})
1854				.hide();
1855
1856		// make sure at least one header is in the tab order
1857		if ( !this.active.length ) {
1858			this.headers.eq( 0 ).attr( "tabIndex", 0 );
1859		} else {
1860			this.active.attr({
1861				"aria-selected": "true",
1862				"aria-expanded": "true",
1863				tabIndex: 0
1864			})
1865			.next()
1866				.attr({
1867					"aria-hidden": "false"
1868				});
1869		}
1870
1871		this._createIcons();
1872
1873		this._setupEvents( options.event );
1874
1875		if ( heightStyle === "fill" ) {
1876			maxHeight = parent.height();
1877			this.element.siblings( ":visible" ).each(function() {
1878				var elem = $( this ),
1879					position = elem.css( "position" );
1880
1881				if ( position === "absolute" || position === "fixed" ) {
1882					return;
1883				}
1884				maxHeight -= elem.outerHeight( true );
1885			});
1886
1887			this.headers.each(function() {
1888				maxHeight -= $( this ).outerHeight( true );
1889			});
1890
1891			this.headers.next()
1892				.each(function() {
1893					$( this ).height( Math.max( 0, maxHeight -
1894						$( this ).innerHeight() + $( this ).height() ) );
1895				})
1896				.css( "overflow", "auto" );
1897		} else if ( heightStyle === "auto" ) {
1898			maxHeight = 0;
1899			this.headers.next()
1900				.each(function() {
1901					maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1902				})
1903				.height( maxHeight );
1904		}
1905	},
1906
1907	_activate: function( index ) {
1908		var active = this._findActive( index )[ 0 ];
1909
1910		// trying to activate the already active panel
1911		if ( active === this.active[ 0 ] ) {
1912			return;
1913		}
1914
1915		// trying to collapse, simulate a click on the currently active header
1916		active = active || this.active[ 0 ];
1917
1918		this._eventHandler({
1919			target: active,
1920			currentTarget: active,
1921			preventDefault: $.noop
1922		});
1923	},
1924
1925	_findActive: function( selector ) {
1926		return typeof selector === "number" ? this.headers.eq( selector ) : $();
1927	},
1928
1929	_setupEvents: function( event ) {
1930		var events = {
1931			keydown: "_keydown"
1932		};
1933		if ( event ) {
1934			$.each( event.split( " " ), function( index, eventName ) {
1935				events[ eventName ] = "_eventHandler";
1936			});
1937		}
1938
1939		this._off( this.headers.add( this.headers.next() ) );
1940		this._on( this.headers, events );
1941		this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1942		this._hoverable( this.headers );
1943		this._focusable( this.headers );
1944	},
1945
1946	_eventHandler: function( event ) {
1947		var options = this.options,
1948			active = this.active,
1949			clicked = $( event.currentTarget ),
1950			clickedIsActive = clicked[ 0 ] === active[ 0 ],
1951			collapsing = clickedIsActive && options.collapsible,
1952			toShow = collapsing ? $() : clicked.next(),
1953			toHide = active.next(),
1954			eventData = {
1955				oldHeader: active,
1956				oldPanel: toHide,
1957				newHeader: collapsing ? $() : clicked,
1958				newPanel: toShow
1959			};
1960
1961		event.preventDefault();
1962
1963		if (
1964				// click on active header, but not collapsible
1965				( clickedIsActive && !options.collapsible ) ||
1966				// allow canceling activation
1967				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1968			return;
1969		}
1970
1971		options.active = collapsing ? false : this.headers.index( clicked );
1972
1973		// when the call to ._toggle() comes after the class changes
1974		// it causes a very odd bug in IE 8 (see #6720)
1975		this.active = clickedIsActive ? $() : clicked;
1976		this._toggle( eventData );
1977
1978		// switch classes
1979		// corner classes on the previously active header stay after the animation
1980		active.removeClass( "ui-accordion-header-active ui-state-active" );
1981		if ( options.icons ) {
1982			active.children( ".ui-accordion-header-icon" )
1983				.removeClass( options.icons.activeHeader )
1984				.addClass( options.icons.header );
1985		}
1986
1987		if ( !clickedIsActive ) {
1988			clicked
1989				.removeClass( "ui-corner-all" )
1990				.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1991			if ( options.icons ) {
1992				clicked.children( ".ui-accordion-header-icon" )
1993					.removeClass( options.icons.header )
1994					.addClass( options.icons.activeHeader );
1995			}
1996
1997			clicked
1998				.next()
1999				.addClass( "ui-accordion-content-active" );
2000		}
2001	},
2002
2003	_toggle: function( data ) {
2004		var toShow = data.newPanel,
2005			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2006
2007		// handle activating a panel during the animation for another activation
2008		this.prevShow.add( this.prevHide ).stop( true, true );
2009		this.prevShow = toShow;
2010		this.prevHide = toHide;
2011
2012		if ( this.options.animate ) {
2013			this._animate( toShow, toHide, data );
2014		} else {
2015			toHide.hide();
2016			toShow.show();
2017			this._toggleComplete( data );
2018		}
2019
2020		toHide.attr({
2021			"aria-hidden": "true"
2022		});
2023		toHide.prev().attr({
2024			"aria-selected": "false",
2025			"aria-expanded": "false"
2026		});
2027		// if we're switching panels, remove the old header from the tab order
2028		// if we're opening from collapsed state, remove the previous header from the tab order
2029		// if we're collapsing, then keep the collapsing header in the tab order
2030		if ( toShow.length && toHide.length ) {
2031			toHide.prev().attr({
2032				"tabIndex": -1,
2033				"aria-expanded": "false"
2034			});
2035		} else if ( toShow.length ) {
2036			this.headers.filter(function() {
2037				return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
2038			})
2039			.attr( "tabIndex", -1 );
2040		}
2041
2042		toShow
2043			.attr( "aria-hidden", "false" )
2044			.prev()
2045				.attr({
2046					"aria-selected": "true",
2047					"aria-expanded": "true",
2048					tabIndex: 0
2049				});
2050	},
2051
2052	_animate: function( toShow, toHide, data ) {
2053		var total, easing, duration,
2054			that = this,
2055			adjust = 0,
2056			boxSizing = toShow.css( "box-sizing" ),
2057			down = toShow.length &&
2058				( !toHide.length || ( toShow.index() < toHide.index() ) ),
2059			animate = this.options.animate || {},
2060			options = down && animate.down || animate,
2061			complete = function() {
2062				that._toggleComplete( data );
2063			};
2064
2065		if ( typeof options === "number" ) {
2066			duration = options;
2067		}
2068		if ( typeof options === "string" ) {
2069			easing = options;
2070		}
2071		// fall back from options to animation in case of partial down settings
2072		easing = easing || options.easing || animate.easing;
2073		duration = duration || options.duration || animate.duration;
2074
2075		if ( !toHide.length ) {
2076			return toShow.animate( this.showProps, duration, easing, complete );
2077		}
2078		if ( !toShow.length ) {
2079			return toHide.animate( this.hideProps, duration, easing, complete );
2080		}
2081
2082		total = toShow.show().outerHeight();
2083		toHide.animate( this.hideProps, {
2084			duration: duration,
2085			easing: easing,
2086			step: function( now, fx ) {
2087				fx.now = Math.round( now );
2088			}
2089		});
2090		toShow
2091			.hide()
2092			.animate( this.showProps, {
2093				duration: duration,
2094				easing: easing,
2095				complete: complete,
2096				step: function( now, fx ) {
2097					fx.now = Math.round( now );
2098					if ( fx.prop !== "height" ) {
2099						if ( boxSizing === "content-box" ) {
2100							adjust += fx.now;
2101						}
2102					} else if ( that.options.heightStyle !== "content" ) {
2103						fx.now = Math.round( total - toHide.outerHeight() - adjust );
2104						adjust = 0;
2105					}
2106				}
2107			});
2108	},
2109
2110	_toggleComplete: function( data ) {
2111		var toHide = data.oldPanel;
2112
2113		toHide
2114			.removeClass( "ui-accordion-content-active" )
2115			.prev()
2116				.removeClass( "ui-corner-top" )
2117				.addClass( "ui-corner-all" );
2118
2119		// Work around for rendering bug in IE (#5421)
2120		if ( toHide.length ) {
2121			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2122		}
2123		this._trigger( "activate", null, data );
2124	}
2125});
2126
2127
2128/*!
2129 * jQuery UI Menu 1.11.4
2130 * http://jqueryui.com
2131 *
2132 * Copyright jQuery Foundation and other contributors
2133 * Released under the MIT license.
2134 * http://jquery.org/license
2135 *
2136 * http://api.jqueryui.com/menu/
2137 */
2138
2139
2140var menu = $.widget( "ui.menu", {
2141	version: "1.11.4",
2142	defaultElement: "<ul>",
2143	delay: 300,
2144	options: {
2145		icons: {
2146			submenu: "ui-icon-carat-1-e"
2147		},
2148		items: "> *",
2149		menus: "ul",
2150		position: {
2151			my: "left-1 top",
2152			at: "right top"
2153		},
2154		role: "menu",
2155
2156		// callbacks
2157		blur: null,
2158		focus: null,
2159		select: null
2160	},
2161
2162	_create: function() {
2163		this.activeMenu = this.element;
2164
2165		// Flag used to prevent firing of the click handler
2166		// as the event bubbles up through nested menus
2167		this.mouseHandled = false;
2168		this.element
2169			.uniqueId()
2170			.addClass( "ui-menu ui-widget ui-widget-content" )
2171			.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2172			.attr({
2173				role: this.options.role,
2174				tabIndex: 0
2175			});
2176
2177		if ( this.options.disabled ) {
2178			this.element
2179				.addClass( "ui-state-disabled" )
2180				.attr( "aria-disabled", "true" );
2181		}
2182
2183		this._on({
2184			// Prevent focus from sticking to links inside menu after clicking
2185			// them (focus should always stay on UL during navigation).
2186			"mousedown .ui-menu-item": function( event ) {
2187				event.preventDefault();
2188			},
2189			"click .ui-menu-item": function( event ) {
2190				var target = $( event.target );
2191				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2192					this.select( event );
2193
2194					// Only set the mouseHandled flag if the event will bubble, see #9469.
2195					if ( !event.isPropagationStopped() ) {
2196						this.mouseHandled = true;
2197					}
2198
2199					// Open submenu on click
2200					if ( target.has( ".ui-menu" ).length ) {
2201						this.expand( event );
2202					} else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2203
2204						// Redirect focus to the menu
2205						this.element.trigger( "focus", [ true ] );
2206
2207						// If the active item is on the top level, let it stay active.
2208						// Otherwise, blur the active item since it is no longer visible.
2209						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2210							clearTimeout( this.timer );
2211						}
2212					}
2213				}
2214			},
2215			"mouseenter .ui-menu-item": function( event ) {
2216				// Ignore mouse events while typeahead is active, see #10458.
2217				// Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2218				// is over an item in the menu
2219				if ( this.previousFilter ) {
2220					return;
2221				}
2222				var target = $( event.currentTarget );
2223				// Remove ui-state-active class from siblings of the newly focused menu item
2224				// to avoid a jump caused by adjacent elements both having a class with a border
2225				target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2226				this.focus( event, target );
2227			},
2228			mouseleave: "collapseAll",
2229			"mouseleave .ui-menu": "collapseAll",
2230			focus: function( event, keepActiveItem ) {
2231				// If there's already an active item, keep it active
2232				// If not, activate the first item
2233				var item = this.active || this.element.find( this.options.items ).eq( 0 );
2234
2235				if ( !keepActiveItem ) {
2236					this.focus( event, item );
2237				}
2238			},
2239			blur: function( event ) {
2240				this._delay(function() {
2241					if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2242						this.collapseAll( event );
2243					}
2244				});
2245			},
2246			keydown: "_keydown"
2247		});
2248
2249		this.refresh();
2250
2251		// Clicks outside of a menu collapse any open menus
2252		this._on( this.document, {
2253			click: function( event ) {
2254				if ( this._closeOnDocumentClick( event ) ) {
2255					this.collapseAll( event );
2256				}
2257
2258				// Reset the mouseHandled flag
2259				this.mouseHandled = false;
2260			}
2261		});
2262	},
2263
2264	_destroy: function() {
2265		// Destroy (sub)menus
2266		this.element
2267			.removeAttr( "aria-activedescendant" )
2268			.find( ".ui-menu" ).addBack()
2269				.removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2270				.removeAttr( "role" )
2271				.removeAttr( "tabIndex" )
2272				.removeAttr( "aria-labelledby" )
2273				.removeAttr( "aria-expanded" )
2274				.removeAttr( "aria-hidden" )
2275				.removeAttr( "aria-disabled" )
2276				.removeUniqueId()
2277				.show();
2278
2279		// Destroy menu items
2280		this.element.find( ".ui-menu-item" )
2281			.removeClass( "ui-menu-item" )
2282			.removeAttr( "role" )
2283			.removeAttr( "aria-disabled" )
2284			.removeUniqueId()
2285			.removeClass( "ui-state-hover" )
2286			.removeAttr( "tabIndex" )
2287			.removeAttr( "role" )
2288			.removeAttr( "aria-haspopup" )
2289			.children().each( function() {
2290				var elem = $( this );
2291				if ( elem.data( "ui-menu-submenu-carat" ) ) {
2292					elem.remove();
2293				}
2294			});
2295
2296		// Destroy menu dividers
2297		this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2298	},
2299
2300	_keydown: function( event ) {
2301		var match, prev, character, skip,
2302			preventDefault = true;
2303
2304		switch ( event.keyCode ) {
2305		case $.ui.keyCode.PAGE_UP:
2306			this.previousPage( event );
2307			break;
2308		case $.ui.keyCode.PAGE_DOWN:
2309			this.nextPage( event );
2310			break;
2311		case $.ui.keyCode.HOME:
2312			this._move( "first", "first", event );
2313			break;
2314		case $.ui.keyCode.END:
2315			this._move( "last", "last", event );
2316			break;
2317		case $.ui.keyCode.UP:
2318			this.previous( event );
2319			break;
2320		case $.ui.keyCode.DOWN:
2321			this.next( event );
2322			break;
2323		case $.ui.keyCode.LEFT:
2324			this.collapse( event );
2325			break;
2326		case $.ui.keyCode.RIGHT:
2327			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2328				this.expand( event );
2329			}
2330			break;
2331		case $.ui.keyCode.ENTER:
2332		case $.ui.keyCode.SPACE:
2333			this._activate( event );
2334			break;
2335		case $.ui.keyCode.ESCAPE:
2336			this.collapse( event );
2337			break;
2338		default:
2339			preventDefault = false;
2340			prev = this.previousFilter || "";
2341			character = String.fromCharCode( event.keyCode );
2342			skip = false;
2343
2344			clearTimeout( this.filterTimer );
2345
2346			if ( character === prev ) {
2347				skip = true;
2348			} else {
2349				character = prev + character;
2350			}
2351
2352			match = this._filterMenuItems( character );
2353			match = skip && match.index( this.active.next() ) !== -1 ?
2354				this.active.nextAll( ".ui-menu-item" ) :
2355				match;
2356
2357			// If no matches on the current filter, reset to the last character pressed
2358			// to move down the menu to the first item that starts with that character
2359			if ( !match.length ) {
2360				character = String.fromCharCode( event.keyCode );
2361				match = this._filterMenuItems( character );
2362			}
2363
2364			if ( match.length ) {
2365				this.focus( event, match );
2366				this.previousFilter = character;
2367				this.filterTimer = this._delay(function() {
2368					delete this.previousFilter;
2369				}, 1000 );
2370			} else {
2371				delete this.previousFilter;
2372			}
2373		}
2374
2375		if ( preventDefault ) {
2376			event.preventDefault();
2377		}
2378	},
2379
2380	_activate: function( event ) {
2381		if ( !this.active.is( ".ui-state-disabled" ) ) {
2382			if ( this.active.is( "[aria-haspopup='true']" ) ) {
2383				this.expand( event );
2384			} else {
2385				this.select( event );
2386			}
2387		}
2388	},
2389
2390	refresh: function() {
2391		var menus, items,
2392			that = this,
2393			icon = this.options.icons.submenu,
2394			submenus = this.element.find( this.options.menus );
2395
2396		this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2397
2398		// Initialize nested menus
2399		submenus.filter( ":not(.ui-menu)" )
2400			.addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2401			.hide()
2402			.attr({
2403				role: this.options.role,
2404				"aria-hidden": "true",
2405				"aria-expanded": "false"
2406			})
2407			.each(function() {
2408				var menu = $( this ),
2409					item = menu.parent(),
2410					submenuCarat = $( "<span>" )
2411						.addClass( "ui-menu-icon ui-icon " + icon )
2412						.data( "ui-menu-submenu-carat", true );
2413
2414				item
2415					.attr( "aria-haspopup", "true" )
2416					.prepend( submenuCarat );
2417				menu.attr( "aria-labelledby", item.attr( "id" ) );
2418			});
2419
2420		menus = submenus.add( this.element );
2421		items = menus.find( this.options.items );
2422

2423		// Initialize menu-items containing spaces and/or dashes only as dividers
2424		items.not( ".ui-menu-item" ).each(function() {
2425			var item = $( this );
2426			if ( that._isDivider( item ) ) {
2427				item.addClass( "ui-widget-content ui-menu-divider" );
2428			}
2429		});
2430
2431		// Don't refresh list items that are already adapted
2432		items.not( ".ui-menu-item, .ui-menu-divider" )
2433			.addClass( "ui-menu-item" )
2434			.uniqueId()
2435			.attr({
2436				tabIndex: -1,
2437				role: this._itemRole()
2438			});
2439
2440		// Add aria-disabled attribute to any disabled menu item
2441		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2442
2443		// If the active item has been removed, blur the menu
2444		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2445			this.blur();
2446		}
2447	},
2448
2449	_itemRole: function() {
2450		return {
2451			menu: "menuitem",
2452			listbox: "option"
2453		}[ this.options.role ];
2454	},
2455
2456	_setOption: function( key, value ) {
2457		if ( key === "icons" ) {
2458			this.element.find( ".ui-menu-icon" )
2459				.removeClass( this.options.icons.submenu )
2460				.addClass( value.submenu );
2461		}
2462		if ( key === "disabled" ) {
2463			this.element
2464				.toggleClass( "ui-state-disabled", !!value )
2465				.attr( "aria-disabled", value );
2466		}
2467		this._super( key, value );
2468	},
2469
2470	focus: function( event, item ) {
2471		var nested, focused;
2472		this.blur( event, event && event.type === "focus" );
2473
2474		this._scrollIntoView( item );
2475
2476		this.active = item.first();
2477		focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2478		// Only update aria-activedescendant if there's a role
2479		// otherwise we assume focus is managed elsewhere
2480		if ( this.options.role ) {
2481			this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2482		}
2483
2484		// Highlight active parent menu item, if any
2485		this.active
2486			.parent()
2487			.closest( ".ui-menu-item" )
2488			.addClass( "ui-state-active" );
2489
2490		if ( event && event.type === "keydown" ) {
2491			this._close();
2492		} else {
2493			this.timer = this._delay(function() {
2494				this._close();
2495			}, this.delay );
2496		}
2497
2498		nested = item.children( ".ui-menu" );
2499		if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2500			this._startOpening(nested);
2501		}
2502		this.activeMenu = item.parent();
2503
2504		this._trigger( "focus", event, { item: item } );
2505	},
2506
2507	_scrollIntoView: function( item ) {
2508		var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2509		if ( this._hasScroll() ) {
2510			borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2511			paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2512			offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2513			scroll = this.activeMenu.scrollTop();
2514			elementHeight = this.activeMenu.height();
2515			itemHeight = item.outerHeight();
2516
2517			if ( offset < 0 ) {
2518				this.activeMenu.scrollTop( scroll + offset );
2519			} else if ( offset + itemHeight > elementHeight ) {
2520				this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2521			}
2522		}
2523	},
2524
2525	blur: function( event, fromFocus ) {
2526		if ( !fromFocus ) {
2527			clearTimeout( this.timer );
2528		}
2529
2530		if ( !this.active ) {
2531			return;
2532		}
2533
2534		this.active.removeClass( "ui-state-focus" );
2535		this.active = null;
2536
2537		this._trigger( "blur", event, { item: this.active } );
2538	},
2539
2540	_startOpening: function( submenu ) {
2541		clearTimeout( this.timer );
2542
2543		// Don't open if already open fixes a Firefox bug that caused a .5 pixel
2544		// shift in the submenu position when mousing over the carat icon
2545		if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2546			return;
2547		}
2548
2549		this.timer = this._delay(function() {
2550			this._close();
2551			this._open( submenu );
2552		}, this.delay );
2553	},
2554
2555	_open: function( submenu ) {
2556		var position = $.extend({
2557			of: this.active
2558		}, this.options.position );
2559
2560		clearTimeout( this.timer );
2561		this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2562			.hide()
2563			.attr( "aria-hidden", "true" );
2564
2565		submenu
2566			.show()
2567			.removeAttr( "aria-hidden" )
2568			.attr( "aria-expanded", "true" )
2569			.position( position );
2570	},
2571
2572	collapseAll: function( event, all ) {
2573		clearTimeout( this.timer );
2574		this.timer = this._delay(function() {

2575			// If we were passed an event, look for the submenu that contains the event
2576			var currentMenu = all ? this.element :
2577				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2578
2579			// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2580			if ( !currentMenu.length ) {
2581				currentMenu = this.element;
2582			}
2583
2584			this._close( currentMenu );
2585
2586			this.blur( event );
2587			this.activeMenu = currentMenu;
2588		}, this.delay );
2589	},
2590
2591	// With no arguments, closes the currently active menu - if nothing is active
2592	// it closes all menus.  If passed an argument, it will search for menus BELOW
2593	_close: function( startMenu ) {
2594		if ( !startMenu ) {
2595			startMenu = this.active ? this.active.parent() : this.element;
2596		}
2597
2598		startMenu
2599			.find( ".ui-menu" )
2600				.hide()
2601				.attr( "aria-hidden", "true" )
2602				.attr( "aria-expanded", "false" )
2603			.end()
2604			.find( ".ui-state-active" ).not( ".ui-state-focus" )
2605				.removeClass( "ui-state-active" );
2606	},
2607
2608	_closeOnDocumentClick: function( event ) {
2609		return !$( event.target ).closest( ".ui-menu" ).length;
2610	},
2611
2612	_isDivider: function( item ) {
2613
2614		// Match hyphen, em dash, en dash
2615		return !/[^\-\u2014\u2013\s]/.test( item.text() );
2616	},
2617
2618	collapse: function( event ) {
2619		var newItem = this.active &&
2620			this.active.parent().closest( ".ui-menu-item", this.element );
2621		if ( newItem && newItem.length ) {
2622			this._close();
2623			this.focus( event, newItem );
2624		}
2625	},
2626
2627	expand: function( event ) {
2628		var newItem = this.active &&
2629			this.active
2630				.children( ".ui-menu " )
2631				.find( this.options.items )
2632				.first();
2633
2634		if ( newItem && newItem.length ) {
2635			this._open( newItem.parent() );
2636
2637			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2638			this._delay(function() {
2639				this.focus( event, newItem );
2640			});
2641		}
2642	},
2643
2644	next: function( event ) {
2645		this._move( "next", "first", event );
2646	},
2647
2648	previous: function( event ) {
2649		this._move( "prev", "last", event );
2650	},
2651
2652	isFirstItem: function() {
2653		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2654	},
2655
2656	isLastItem: function() {
2657		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2658	},
2659
2660	_move: function( direction, filter, event ) {
2661		var next;
2662		if ( this.active ) {
2663			if ( direction === "first" || direction === "last" ) {
2664				next = this.active
2665					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2666					.eq( -1 );
2667			} else {
2668				next = this.active
2669					[ direction + "All" ]( ".ui-menu-item" )
2670					.eq( 0 );
2671			}
2672		}
2673		if ( !next || !next.length || !this.active ) {
2674			next = this.activeMenu.find( this.options.items )[ filter ]();
2675		}
2676
2677		this.focus( event, next );
2678	},
2679
2680	nextPage: function( event ) {
2681		var item, base, height;
2682
2683		if ( !this.active ) {
2684			this.next( event );
2685			return;
2686		}
2687		if ( this.isLastItem() ) {
2688			return;
2689		}
2690		if ( this._hasScroll() ) {
2691			base = this.active.offset().top;
2692			height = this.element.height();
2693			this.active.nextAll( ".ui-menu-item" ).each(function() {
2694				item = $( this );
2695				return item.offset().top - base - height < 0;
2696			});
2697
2698			this.focus( event, item );
2699		} else {
2700			this.focus( event, this.activeMenu.find( this.options.items )
2701				[ !this.active ? "first" : "last" ]() );
2702		}
2703	},
2704
2705	previousPage: function( event ) {
2706		var item, base, height;
2707		if ( !this.active ) {
2708			this.next( event );
2709			return;
2710		}
2711		if ( this.isFirstItem() ) {
2712			return;
2713		}
2714		if ( this._hasScroll() ) {
2715			base = this.active.offset().top;
2716			height = this.element.height();
2717			this.active.prevAll( ".ui-menu-item" ).each(function() {
2718				item = $( this );
2719				return item.offset().top - base + height > 0;
2720			});
2721
2722			this.focus( event, item );
2723		} else {
2724			this.focus( event, this.activeMenu.find( this.options.items ).first() );
2725		}
2726	},
2727
2728	_hasScroll: function() {
2729		return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2730	},
2731
2732	select: function( event ) {
2733		// TODO: It should never be possible to not have an active item at this
2734		// point, but the tests don't trigger mouseenter before click.
2735		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2736		var ui = { item: this.active };
2737		if ( !this.active.has( ".ui-menu" ).length ) {
2738			this.collapseAll( event, true );
2739		}
2740		this._trigger( "select", event, ui );
2741	},
2742
2743	_filterMenuItems: function(character) {
2744		var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2745			regex = new RegExp( "^" + escapedCharacter, "i" );
2746
2747		return this.activeMenu
2748			.find( this.options.items )
2749
2750			// Only match on items, not dividers or other content (#10571)
2751			.filter( ".ui-menu-item" )
2752			.filter(function() {
2753				return regex.test( $.trim( $( this ).text() ) );
2754			});
2755	}
2756});
2757
2758
2759/*!
2760 * jQuery UI Autocomplete 1.11.4
2761 * http://jqueryui.com
2762 *
2763 * Copyright jQuery Foundation and other contributors
2764 * Released under the MIT license.
2765 * http://jquery.org/license
2766 *
2767 * http://api.jqueryui.com/autocomplete/
2768 */
2769
2770
2771$.widget( "ui.autocomplete", {
2772	version: "1.11.4",
2773	defaultElement: "<input>",
2774	options: {
2775		appendTo: null,
2776		autoFocus: false,
2777		delay: 300,
2778		minLength: 1,
2779		position: {
2780			my: "left top",
2781			at: "left bottom",
2782			collision: "none"
2783		},
2784		source: null,
2785
2786		// callbacks
2787		change: null,
2788		close: null,
2789		focus: null,
2790		open: null,
2791		response: null,
2792		search: null,
2793		select: null
2794	},
2795
2796	requestIndex: 0,
2797	pending: 0,
2798
2799	_create: function() {
2800		// Some browsers only repeat keydown events, not keypress events,
2801		// so we use the suppressKeyPress flag to determine if we've already
2802		// handled the keydown event. #7269
2803		// Unfortunately the code for & in keypress is the same as the up arrow,
2804		// so we use the suppressKeyPressRepeat flag to avoid handling keypress
2805		// events when we know the keydown event was used to modify the
2806		// search term. #7799
2807		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2808			nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2809			isTextarea = nodeName === "textarea",
2810			isInput = nodeName === "input";
2811
2812		this.isMultiLine =
2813			// Textareas are always multi-line
2814			isTextarea ? true :
2815			// Inputs are always single-line, even if inside a contentEditable element
2816			// IE also treats inputs as contentEditable
2817			isInput ? false :
2818			// All other element types are determined by whether or not they're contentEditable
2819			this.element.prop( "isContentEditable" );
2820
2821		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2822		this.isNewMenu = true;
2823
2824		this.element
2825			.addClass( "ui-autocomplete-input" )
2826			.attr( "autocomplete", "off" );
2827
2828		this._on( this.element, {
2829			keydown: function( event ) {
2830				if ( this.element.prop( "readOnly" ) ) {
2831					suppressKeyPress = true;
2832					suppressInput = true;
2833					suppressKeyPressRepeat = true;
2834					return;
2835				}
2836
2837				suppressKeyPress = false;
2838				suppressInput = false;
2839				suppressKeyPressRepeat = false;
2840				var keyCode = $.ui.keyCode;
2841				switch ( event.keyCode ) {
2842				case keyCode.PAGE_UP:
2843					suppressKeyPress = true;
2844					this._move( "previousPage", event );
2845					break;
2846				case keyCode.PAGE_DOWN:
2847					suppressKeyPress = true;
2848					this._move( "nextPage", event );
2849					break;
2850				case keyCode.UP:
2851					suppressKeyPress = true;
2852					this._keyEvent( "previous", event );
2853					break;
2854				case keyCode.DOWN:
2855					suppressKeyPress = true;
2856					this._keyEvent( "next", event );
2857					break;
2858				case keyCode.ENTER:
2859					// when menu is open and has focus
2860					if ( this.menu.active ) {
2861						// #6055 - Opera still allows the keypress to occur
2862						// which causes forms to submit
2863						suppressKeyPress = true;
2864						event.preventDefault();
2865						this.menu.select( event );
2866					}
2867					break;
2868				case keyCode.TAB:
2869					if ( this.menu.active ) {
2870						this.menu.select( event );
2871					}
2872					break;
2873				case keyCode.ESCAPE:
2874					if ( this.menu.element.is( ":visible" ) ) {
2875						if ( !this.isMultiLine ) {
2876							this._value( this.term );
2877						}
2878						this.close( event );
2879						// Different browsers have different default behavior for escape
2880						// Single press can mean undo or clear
2881						// Double press in IE means clear the whole form
2882						event.preventDefault();
2883					}
2884					break;
2885				default:
2886					suppressKeyPressRepeat = true;
2887					// search timeout should be triggered before the input value is changed
2888					this._searchTimeout( event );
2889					break;
2890				}
2891			},
2892			keypress: function( event ) {
2893				if ( suppressKeyPress ) {
2894					suppressKeyPress = false;
2895					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2896						event.preventDefault();
2897					}
2898					return;
2899				}
2900				if ( suppressKeyPressRepeat ) {
2901					return;
2902				}
2903
2904				// replicate some key handlers to allow them to repeat in Firefox and Opera
2905				var keyCode = $.ui.keyCode;
2906				switch ( event.keyCode ) {
2907				case keyCode.PAGE_UP:
2908					this._move( "previousPage", event );
2909					break;
2910				case keyCode.PAGE_DOWN:
2911					this._move( "nextPage", event );
2912					break;
2913				case keyCode.UP:
2914					this._keyEvent( "previous", event );
2915					break;
2916				case keyCode.DOWN:
2917					this._keyEvent( "next", event );
2918					break;
2919				}
2920			},
2921			input: function( event ) {
2922				if ( suppressInput ) {
2923					suppressInput = false;
2924					event.preventDefault();
2925					return;
2926				}
2927				this._searchTimeout( event );
2928			},
2929			focus: function() {
2930				this.selectedItem = null;
2931				this.previous = this._value();
2932			},
2933			blur: function( event ) {
2934				if ( this.cancelBlur ) {
2935					delete this.cancelBlur;
2936					return;
2937				}
2938
2939				clearTimeout( this.searching );
2940				this.close( event );
2941				this._change( event );
2942			}
2943		});
2944
2945		this._initSource();
2946		this.menu = $( "<ul>" )
2947			.addClass( "ui-autocomplete ui-front" )
2948			.appendTo( this._appendTo() )
2949			.menu({
2950				// disable ARIA support, the live region takes care of that
2951				role: null
2952			})
2953			.hide()
2954			.menu( "instance" );
2955
2956		this._on( this.menu.element, {
2957			mousedown: function( event ) {
2958				// prevent moving focus out of the text field
2959				event.preventDefault();
2960
2961				// IE doesn't prevent moving focus even with event.preventDefault()
2962				// so we set a flag to know when we should ignore the blur event
2963				this.cancelBlur = true;
2964				this._delay(function() {
2965					delete this.cancelBlur;
2966				});
2967
2968				// clicking on the scrollbar causes focus to shift to the body
2969				// but we can't detect a mouseup or a click immediately afterward
2970				// so we have to track the next mousedown and close the menu if
2971				// the user clicks somewhere outside of the autocomplete
2972				var menuElement = this.menu.element[ 0 ];
2973				if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2974					this._delay(function() {
2975						var that = this;
2976						this.document.one( "mousedown", function( event ) {
2977							if ( event.target !== that.element[ 0 ] &&
2978									event.target !== menuElement &&
2979									!$.contains( menuElement, event.target ) ) {
2980								that.close();
2981							}
2982						});
2983					});
2984				}
2985			},
2986			menufocus: function( event, ui ) {
2987				var label, item;
2988				// support: Firefox
2989				// Prevent accidental activation of menu items in Firefox (#7024 #9118)
2990				if ( this.isNewMenu ) {
2991					this.isNewMenu = false;