https://www.penisplus.com/js/jquery-ui.js

1/*! jQuery UI - v1.11.2 - 2014-10-16
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 2014 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.2
19 * http://jqueryui.com
20 *
21 * Copyright 2014 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.2",
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.2
313 * http://jqueryui.com
314 *
315 * Copyright 2014 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		// allow multiple hashes to be passed on init
494		options = !isMethodCall && args.length ?
495			$.widget.extend.apply( null, [ options ].concat(args) ) :
496			options;
497
498		if ( isMethodCall ) {
499			this.each(function() {
500				var methodValue,
501					instance = $.data( this, fullName );
502				if ( options === "instance" ) {
503					returnValue = instance;
504					return false;
505				}
506				if ( !instance ) {
507					return $.error( "cannot call methods on " + name + " prior to initialization; " +
508						"attempted to call method '" + options + "'" );
509				}
510				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
511					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
512				}
513				methodValue = instance[ options ].apply( instance, args );
514				if ( methodValue !== instance && methodValue !== undefined ) {
515					returnValue = methodValue && methodValue.jquery ?
516						returnValue.pushStack( methodValue.get() ) :
517						methodValue;
518					return false;
519				}
520			});
521		} else {

521
522			this.each(function() {
523				var instance = $.data( this, fullName );
524				if ( instance ) {
525					instance.option( options || {} );
526					if ( instance._init ) {
527						instance._init();
528					}
529				} else {
530					$.data( this, fullName, new object( options, this ) );
531				}
532			});
533		}
534
535		return returnValue;
536	};
537};
538
539$.Widget = function( /* options, element */ ) {};
540$.Widget._childConstructors = [];
541
542$.Widget.prototype = {
543	widgetName: "widget",
544	widgetEventPrefix: "",
545	defaultElement: "<div>",
546	options: {
547		disabled: false,
548
549		// callbacks
550		create: null
551	},
552	_createWidget: function( options, element ) {
553		element = $( element || this.defaultElement || this )[ 0 ];
554		this.element = $( element );
555		this.uuid = widget_uuid++;
556		this.eventNamespace = "." + this.widgetName + this.uuid;
557
558		this.bindings = $();
559		this.hoverable = $();
560		this.focusable = $();
561
562		if ( element !== this ) {
563			$.data( element, this.widgetFullName, this );
564			this._on( true, this.element, {
565				remove: function( event ) {
566					if ( event.target === element ) {
567						this.destroy();
568					}
569				}
570			});
571			this.document = $( element.style ?
572				// element within the document
573				element.ownerDocument :
574				// element is window or document
575				element.document || element );
576			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
577		}
578
579		this.options = $.widget.extend( {},
580			this.options,
581			this._getCreateOptions(),
582			options );
583
584		this._create();
585		this._trigger( "create", null, this._getCreateEventData() );
586		this._init();
587	},
588	_getCreateOptions: $.noop,
589	_getCreateEventData: $.noop,
590	_create: $.noop,
591	_init: $.noop,
592
593	destroy: function() {
594		this._destroy();
595		// we can probably remove the unbind calls in 2.0
596		// all event bindings should go through this._on()
597		this.element
598			.unbind( this.eventNamespace )
599			.removeData( this.widgetFullName )
600			// support: jquery <1.6.3
601			// http://bugs.jquery.com/ticket/9413
602			.removeData( $.camelCase( this.widgetFullName ) );
603		this.widget()
604			.unbind( this.eventNamespace )
605			.removeAttr( "aria-disabled" )
606			.removeClass(
607				this.widgetFullName + "-disabled " +
608				"ui-state-disabled" );
609
610		// clean up events and states
611		this.bindings.unbind( this.eventNamespace );
612		this.hoverable.removeClass( "ui-state-hover" );
613		this.focusable.removeClass( "ui-state-focus" );
614	},
615	_destroy: $.noop,
616
617	widget: function() {
618		return this.element;
619	},
620
621	option: function( key, value ) {
622		var options = key,
623			parts,
624			curOption,
625			i;
626
627		if ( arguments.length === 0 ) {
628			// don't return a reference to the internal hash
629			return $.widget.extend( {}, this.options );
630		}
631
632		if ( typeof key === "string" ) {
633			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
634			options = {};
635			parts = key.split( "." );
636			key = parts.shift();
637			if ( parts.length ) {
638				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
639				for ( i = 0; i < parts.length - 1; i++ ) {
640					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
641					curOption = curOption[ parts[ i ] ];
642				}
643				key = parts.pop();
644				if ( arguments.length === 1 ) {
645					return curOption[ key ] === undefined ? null : curOption[ key ];
646				}
647				curOption[ key ] = value;
648			} else {
649				if ( arguments.length === 1 ) {
650					return this.options[ key ] === undefined ? null : this.options[ key ];
651				}
652				options[ key ] = value;
653			}
654		}
655
656		this._setOptions( options );
657
658		return this;
659	},
660	_setOptions: function( options ) {
661		var key;
662
663		for ( key in options ) {
664			this._setOption( key, options[ key ] );
665		}
666
667		return this;
668	},
669	_setOption: function( key, value ) {
670		this.options[ key ] = value;
671
672		if ( key === "disabled" ) {
673			this.widget()
674				.toggleClass( this.widgetFullName + "-disabled", !!value );
675
676			// If the widget is becoming disabled, then nothing is interactive
677			if ( value ) {
678				this.hoverable.removeClass( "ui-state-hover" );
679				this.focusable.removeClass( "ui-state-focus" );
680			}
681		}
682
683		return this;
684	},
685
686	enable: function() {
687		return this._setOptions({ disabled: false });
688	},
689	disable: function() {
690		return this._setOptions({ disabled: true });
691	},
692
693	_on: function( suppressDisabledCheck, element, handlers ) {
694		var delegateElement,
695			instance = this;
696
697		// no suppressDisabledCheck flag, shuffle arguments
698		if ( typeof suppressDisabledCheck !== "boolean" ) {
699			handlers = element;
700			element = suppressDisabledCheck;
701			suppressDisabledCheck = false;
702		}
703
704		// no element argument, shuffle and use this.element
705		if ( !handlers ) {
706			handlers = element;
707			element = this.element;
708			delegateElement = this.widget();
709		} else {
710			element = delegateElement = $( element );
711			this.bindings = this.bindings.add( element );
712		}
713
714		$.each( handlers, function( event, handler ) {
715			function handlerProxy() {
716				// allow widgets to customize the disabled handling
717				// - disabled as an array instead of boolean
718				// - disabled class as method for disabling individual parts
719				if ( !suppressDisabledCheck &&
720						( instance.options.disabled === true ||
721							$( this ).hasClass( "ui-state-disabled" ) ) ) {
722					return;
723				}
724				return ( typeof handler === "string" ? instance[ handler ] : handler )
725					.apply( instance, arguments );
726			}
727
728			// copy the guid so direct unbinding works
729			if ( typeof handler !== "string" ) {
730				handlerProxy.guid = handler.guid =
731					handler.guid || handlerProxy.guid || $.guid++;
732			}
733
734			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
735				eventName = match[1] + instance.eventNamespace,
736				selector = match[2];
737			if ( selector ) {
738				delegateElement.delegate( selector, eventName, handlerProxy );
739			} else {
740				element.bind( eventName, handlerProxy );
741			}
742		});
743	},
744
745	_off: function( element, eventName ) {
746		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
747			this.eventNamespace;
748		element.unbind( eventName ).undelegate( eventName );
749
750		// Clear the stack to avoid memory leaks (#10056)
751		this.bindings = $( this.bindings.not( element ).get() );
752		this.focusable = $( this.focusable.not( element ).get() );
753		this.hoverable = $( this.hoverable.not( element ).get() );
754	},
755
756	_delay: function( handler, delay ) {
757		function handlerProxy() {
758			return ( typeof handler === "string" ? instance[ handler ] : handler )
759				.apply( instance, arguments );
760		}
761		var instance = this;
762		return setTimeout( handlerProxy, delay || 0 );
763	},
764
765	_hoverable: function( element ) {
766		this.hoverable = this.hoverable.add( element );
767		this._on( element, {
768			mouseenter: function( event ) {
769				$( event.currentTarget ).addClass( "ui-state-hover" );
770			},
771			mouseleave: function( event ) {
772				$( event.currentTarget ).removeClass( "ui-state-hover" );
773			}
774		});
775	},
776
777	_focusable: function( element ) {
778		this.focusable = this.focusable.add( element );
779		this._on( element, {
780			focusin: function( event ) {
781				$( event.currentTarget ).addClass( "ui-state-focus" );
782			},
783			focusout: function( event ) {
784				$( event.currentTarget ).removeClass( "ui-state-focus" );
785			}
786		});
787	},
788
789	_trigger: function( type, event, data ) {
790		var prop, orig,
791			callback = this.options[ type ];
792
793		data = data || {};
794		event = $.Event( event );
795		event.type = ( type === this.widgetEventPrefix ?
796			type :
797			this.widgetEventPrefix + type ).toLowerCase();
798		// the original event may come from any element
799		// so we need to reset the target on the new event
800		event.target = this.element[ 0 ];
801
802		// copy original event properties over to the new event
803		orig = event.originalEvent;
804		if ( orig ) {
805			for ( prop in orig ) {
806				if ( !( prop in event ) ) {
807					event[ prop ] = orig[ prop ];
808				}
809			}
810		}
811
812		this.element.trigger( event, data );
813		return !( $.isFunction( callback ) &&
814			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
815			event.isDefaultPrevented() );
816	}
817};
818
819$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
820	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
821		if ( typeof options === "string" ) {
822			options = { effect: options };
823		}
824		var hasOptions,
825			effectName = !options ?
826				method :
827				options === true || typeof options === "number" ?
828					defaultEffect :
829					options.effect || defaultEffect;
830		options = options || {};
831		if ( typeof options === "number" ) {
832			options = { duration: options };
833		}
834		hasOptions = !$.isEmptyObject( options );
835		options.complete = callback;
836		if ( options.delay ) {
837			element.delay( options.delay );
838		}
839		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
840			element[ method ]( options );
841		} else if ( effectName !== method && element[ effectName ] ) {
842			element[ effectName ]( options.duration, options.easing, callback );
843		} else {
844			element.queue(function( next ) {
845				$( this )[ method ]();
846				if ( callback ) {
847					callback.call( element[ 0 ] );
848				}
849				next();
850			});
851		}
852	};
853});
854
855var widget = $.widget;
856
857
858/*!
859 * jQuery UI Mouse 1.11.

8592
860 * http://jqueryui.com
861 *
862 * Copyright 2014 jQuery Foundation and other contributors
863 * Released under the MIT license.
864 * http://jquery.org/license
865 *
866 * http://api.jqueryui.com/mouse/
867 */
868
869
870var mouseHandled = false;
871$( document ).mouseup( function() {
872	mouseHandled = false;
873});
874
875var mouse = $.widget("ui.mouse", {
876	version: "1.11.2",
877	options: {
878		cancel: "input,textarea,button,select,option",
879		distance: 1,
880		delay: 0
881	},
882	_mouseInit: function() {
883		var that = this;
884
885		this.element
886			.bind("mousedown." + this.widgetName, function(event) {
887				return that._mouseDown(event);
888			})
889			.bind("click." + this.widgetName, function(event) {
890				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
891					$.removeData(event.target, that.widgetName + ".preventClickEvent");
892					event.stopImmediatePropagation();
893					return false;
894				}
895			});
896
897		this.started = false;
898	},
899
900	// TODO: make sure destroying one instance of mouse doesn't mess with
901	// other instances of mouse
902	_mouseDestroy: function() {
903		this.element.unbind("." + this.widgetName);
904		if ( this._mouseMoveDelegate ) {
905			this.document
906				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
907				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
908		}
909	},
910
911	_mouseDown: function(event) {
912		// don't let more than one widget handle mouseStart
913		if ( mouseHandled ) {
914			return;
915		}
916
917		this._mouseMoved = false;
918
919		// we may have missed mouseup (out of window)
920		(this._mouseStarted && this._mouseUp(event));
921
922		this._mouseDownEvent = event;
923
924		var that = this,
925			btnIsLeft = (event.which === 1),
926			// event.target.nodeName works around a bug in IE 8 with
927			// disabled inputs (#7620)
928			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
929		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
930			return true;
931		}
932
933		this.mouseDelayMet = !this.options.delay;
934		if (!this.mouseDelayMet) {
935			this._mouseDelayTimer = setTimeout(function() {
936				that.mouseDelayMet = true;
937			}, this.options.delay);
938		}
939
940		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
941			this._mouseStarted = (this._mouseStart(event) !== false);
942			if (!this._mouseStarted) {
943				event.preventDefault();
944				return true;
945			}
946		}
947
948		// Click event may never have fired (Gecko & Opera)
949		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
950			$.removeData(event.target, this.widgetName + ".preventClickEvent");
951		}
952
953		// these delegates are required to keep context
954		this._mouseMoveDelegate = function(event) {
955			return that._mouseMove(event);
956		};
957		this._mouseUpDelegate = function(event) {
958			return that._mouseUp(event);
959		};
960
961		this.document
962			.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
963			.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
964
965		event.preventDefault();
966
967		mouseHandled = true;
968		return true;
969	},
970
971	_mouseMove: function(event) {
972		// Only check for mouseups outside the document if you've moved inside the document
973		// at least once. This prevents the firing of mouseup in the case of IE<9, which will
974		// fire a mousemove event if content is placed under the cursor. See #7778
975		// Support: IE <9
976		if ( this._mouseMoved ) {
977			// IE mouseup check - mouseup happened when mouse was out of window
978			if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
979				return this._mouseUp(event);
980
981			// Iframe mouseup check - mouseup occurred in another document
982			} else if ( !event.which ) {
983				return this._mouseUp( event );
984			}
985		}
986
987		if ( event.which || event.button ) {
988			this._mouseMoved = true;
989		}
990
991		if (this._mouseStarted) {
992			this._mouseDrag(event);
993			return event.preventDefault();
994		}
995
996		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
997			this._mouseStarted =
998				(this._mouseStart(this._mouseDownEvent, event) !== false);
999			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1000		}
1001
1002		return !this._mouseStarted;
1003	},
1004
1005	_mouseUp: function(event) {
1006		this.document
1007			.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1008			.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1009
1010		if (this._mouseStarted) {
1011			this._mouseStarted = false;

1012
1013			if (event.target === this._mouseDownEvent.target) {
1014				$.data(event.target, this.widgetName + ".preventClickEvent", true);
1015			}
1016
1017			this._mouseStop(event);
1018		}
1019
1020		mouseHandled = false;
1021		return false;
1022	},
1023
1024	_mouseDistanceMet: function(event) {
1025		return (Math.max(
1026				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1027				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1028			) >= this.options.distance
1029		);
1030	},
1031
1032	_mouseDelayMet: function(/* event */) {
1033		return this.mouseDelayMet;
1034	},
1035
1036	// These are placeholder methods, to be overriden by extending plugin
1037	_mouseStart: function(/* event */) {},
1038	_mouseDrag: function(/* event */) {},
1039	_mouseStop: function(/* event */) {},
1040	_mouseCapture: function(/* event */) { return true; }
1041});
1042
1043
1044/*!
1045 * jQuery UI Position 1.11.2

1045
1046 * http://jqueryui.com
1047 *
1048 * Copyright 2014 jQuery Foundation and other contributors
1049 * Released under the MIT license.
1050 * http://jquery.org/license
1051 *
1052 * http://api.jqueryui.com/position/
1053 */
1054
1055(function() {
1056
1057$.ui = $.ui || {};
1058
1059var cachedScrollbarWidth, supportsOffsetFractions,
1060	max = Math.max,
1061	abs = Math.abs,
1062	round = Math.round,
1063	rhorizontal = /left|center|right/,
1064	rvertical = /top|center|bottom/,
1065	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1066	rposition = /^\w+/,
1067	rpercent = /%$/,
1068	_position = $.fn.position;
1069
1070function getOffsets( offsets, width, height ) {
1071	return [
1072		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1073		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1074	];
1075}
1076
1077function parseCss( element, property ) {
1078	return parseInt( $.css( element, property ), 10 ) || 0;
1079}
1080
1081function getDimensions( elem ) {
1082	var raw = elem[0];
1083	if ( raw.nodeType === 9 ) {
1084		return {
1085			width: elem.width(),
1086			height: elem.height(),
1087			offset: { top: 0, left: 0 }
1088		};
1089	}
1090	if ( $.isWindow( raw ) ) {
1091		return {
1092			width: elem.width(),
1093			height: elem.height(),
1094			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1095		};
1096	}
1097	if ( raw.preventDefault ) {
1098		return {
1099			width: 0,
1100			height: 0,
1101			offset: { top: raw.pageY, left: raw.pageX }
1102		};
1103	}
1104	return {
1105		width: elem.outerWidth(),
1106		height: elem.outerHeight(),
1107		offset: elem.offset()
1108	};
1109}
1110
1111$.position = {
1112	scrollbarWidth: function() {
1113		if ( cachedScrollbarWidth !== undefined ) {
1114			return cachedScrollbarWidth;
1115		}
1116		var w1, w2,
1117			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1118			innerDiv = div.children()[0];
1119
1120		$( "body" ).append( div );
1121		w1 = innerDiv.offsetWidth;
1122		div.css( "overflow", "scroll" );
1123
1124		w2 = innerDiv.offsetWidth;
1125
1126		if ( w1 === w2 ) {
1127			w2 = div[0].clientWidth;
1128		}
1129
1130		div.remove();
1131
1132		return (cachedScrollbarWidth = w1 - w2);
1133	},
1134	getScrollInfo: function( within ) {
1135		var overflowX = within.isWindow || within.isDocument ? "" :
1136				within.element.css( "overflow-x" ),
1137			overflowY = within.isWindow || within.isDocument ? "" :
1138				within.element.css( "overflow-y" ),
1139			hasOverflowX = overflowX === "scroll" ||
1140				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1141			hasOverflowY = overflowY === "scroll" ||
1142				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1143		return {
1144			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1145			height: hasOverflowX ? $.position.scrollbarWidth() : 0
1146		};
1147	},
1148	getWithinInfo: function( element ) {
1149		var withinElement = $( element || window ),
1150			isWindow = $.isWindow( withinElement[0] ),
1151			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1152		return {
1153			element: withinElement,
1154			isWindow: isWindow,
1155			isDocument: isDocument,
1156			offset: withinElement.offset() || { left: 0, top: 0 },
1157			scrollLeft: withinElement.scrollLeft(),
1158			scrollTop: withinElement.scrollTop(),
1159
1160			// support: jQuery 1.6.x
1161			// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1162			width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1163			height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1164		};
1165	}
1166};
1167
1168$.fn.position = function( options ) {
1169	if ( !options || !options.of ) {
1170		return _position.apply( this, arguments );
1171	}
1172
1173	// make a copy, we don't want to modify arguments
1174	options = $.extend( {}, options );
1175
1176	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1177		target = $( options.of ),
1178		within = $.position.getWithinInfo( options.within ),
1179		scrollInfo = $.position.getScrollInfo( within ),
1180		collision = ( options.collision || "flip" ).split( " " ),
1181		offsets = {};
1182
1183	dimensions = getDimensions( target );
1184	if ( target[0].preventDefault ) {
1185		// force left top to allow flipping
1186		options.at = "left top";
1187	}
1188	targetWidth = dimensions.width;
1189	targetHeight = dimensions.height;
1190	targetOffset = dimensions.offset;
1191	// clone to reuse original targetOffset later
1192	basePosition = $.extend( {}, targetOffset );
1193
1194	// force my and at to have valid horizontal and vertical positions
1195	// if a value is missing or invalid, it will be converted to center
1196	$.each( [ "my", "at" ], function() {
1197		var pos = ( options[ this ] || "" ).split( " " ),
1198			horizontalOffset,
1199			verticalOffset;
1200
1201		if ( pos.length === 1) {
1202			pos = rhorizontal.test( pos[ 0 ] ) ?
1203				pos.concat( [ "center" ] ) :
1204				rvertical.test( pos[ 0 ] ) ?
1205					[ "center" ].concat( pos ) :
1206					[ "center", "center" ];
1207		}
1208		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1209		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1210
1211		// calculate offsets
1212		horizontalOffset = roffset.exec( pos[ 0 ] );
1213		verticalOffset = roffset.exec( pos[ 1 ] );
1214		offsets[ this ] = [
1215			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1216			verticalOffset ? verticalOffset[ 0 ] : 0
1217		];
1218
1219		// reduce to just the positions without the offsets
1220		options[ this ] = [
1221			rposition.exec( pos[ 0 ] )[ 0 ],
1222			rposition.exec( pos[ 1 ] )[ 0 ]
1223		];
1224	});
1225
1226	// normalize collision option
1227	if ( collision.length === 1 ) {
1228		collision[ 1 ] = collision[ 0 ];
1229	}
1230
1231	if ( options.at[ 0 ] === "right" ) {
1232		basePosition.left += targetWidth;
1233	} else if ( options.at[ 0 ] === "center" ) {
1234		basePosition.left += targetWidth / 2;
1235	}
1236
1237	if ( options.at[ 1 ] === "bottom" ) {
1238		basePosition.top += targetHeight;
1239	} else if ( options.at[ 1 ] === "center" ) {
1240		basePosition.top += targetHeight / 2;
1241	}
1242
1243	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1244	basePosition.left += atOffset[ 0 ];
1245	basePosition.top += atOffset[ 1 ];
1246
1247	return this.each(function() {
1248		var collisionPosition, using,
1249			elem = $( this ),
1250			elemWidth = elem.outerWidth(),
1251			elemHeight = elem.outerHeight(),
1252			marginLeft = parseCss( this, "marginLeft" ),
1253			marginTop = parseCss( this, "marginTop" ),
1254			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1255			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1256			position = $.extend( {}, basePosition ),
1257			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1258
1259		if ( options.my[ 0 ] === "right" ) {
1260			position.left -= elemWidth;
1261		} else if ( options.my[ 0 ] === "center" ) {
1262			position.left -= elemWidth / 2;
1263		}
1264
1265		if ( options.my[ 1 ] === "bottom" ) {
1266			position.top -= elemHeight;
1267		} else if ( options.my[ 1 ] === "center" ) {
1268			position.top -= elemHeight / 2;
1269		}
1270
1271		position.left += myOffset[ 0 ];
1272		position.top += myOffset[ 1 ];
1273
1274		// if the browser doesn't support fractions, then round for consistent results
1275		if ( !supportsOffsetFractions ) {
1276			position.left = round( position.left );
1277			position.top = round( position.top );
1278		}
1279
1280		collisionPosition = {
1281			marginLeft: marginLeft,
1282			marginTop: marginTop
1283		};
1284
1285		$.each( [ "left", "top" ], function( i, dir ) {
1286			if ( $.ui.position[ collision[ i ] ] ) {
1287				$.ui.position[ collision[ i ] ][ dir ]( position, {
1288					targetWidth: targetWidth,
1289					targetHeight: targetHeight,
1290					elemWidth: elemWidth,
1291					elemHeight: elemHeight,
1292					collisionPosition: collisionPosition,
1293					collisionWidth: collisionWidth,
1294					collisionHeight: collisionHeight,
1295					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1296					my: options.my,
1297					at: options.at,
1298					within: within,
1299					elem: elem
1300				});
1301			}
1302		});
1303
1304		if ( options.using ) {
1305			// adds feedback as second argument to using callback, if present
1306			using = function( props ) {
1307				var left = targetOffset.left - position.left,
1308					right = left + targetWidth - elemWidth,
1309					top = targetOffset.top - position.top,
1310					bottom = top + targetHeight - elemHeight,
1311					feedback = {
1312						target: {
1313							element: target,
1314							left: targetOffset.left,
1315							top: targetOffset.top,
1316							width: targetWidth,
1317							height: targetHeight
1318						},
1319						element: {
1320							element: elem,
1321							left: position.left,
1322							top: position.top,
1323							width: elemWidth,
1324							height: elemHeight
1325						},
1326						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1327						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1328					};
1329				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1330					feedback.horizontal = "center";
1331				}
1332				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1333					feedback.vertical = "middle";
1334				}
1335				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1336					feedback.important = "horizontal";
1337				} else {
1338					feedback.important = "vertical";
1339				}
1340				options.using.call( this, props, feedback );
1341			};
1342		}
1343
1344		elem.offset( $.extend( position, { using: using } ) );
1345	});
1346};
1347
1348$.ui.position = {
1349	fit: {
1350		left: function( position, data ) {
1351			var within = data.within,
1352				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1353				outerWidth = within.width,
1354				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1355				overLeft = withinOffset - collisionPosLeft,
1356				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1357				newOverRight;
1358
1359			// element is wider than within
1360			if ( data.collisionWidth > outerWidth ) {
1361				// element is initially over the left side of within
1362				if ( overLeft > 0 && overRight <= 0 ) {
1363					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1364					position.left += overLeft - newOverRight;
1365				// element is initially over right side of within
1366				} else if ( overRight > 0 && overLeft <= 0 ) {
1367					position.left = withinOffset;
1368				// element is initially over both left and right sides of within
1369				} else {
1370					if ( overLeft > overRight ) {
1371						position.left = withinOffset + outerWidth - data.collisionWidth;
1372					} else {
1373						position.left = withinOffset;
1374					}
1375				}
1376			// too far left -> align with left edge
1377			} else if ( overLeft > 0 ) {
1378				position.left += overLeft;
1379			// too far right -> align with right edge
1380			} else if ( overRight > 0 ) {
1381				position.left -= overRight;
1382			// adjust based on position and margin
1383			} else {
1384				position.left = max( position.left - collisionPosLeft, position.left );
1385			}
1386		},
1387		top: function( position, data ) {
1388			var within = data.within,
1389				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1390				outerHeight = data.within.height,
1391				collisionPosTop = position.top - data.collisionPosition.marginTop,
1392				overTop = withinOffset - collisionPosTop,
1393				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1394				newOverBottom;
1395
1396			// element is taller than within
1397			if ( data.collisionHeight > outerHeight ) {
1398				// element is initially over the top of within
1399				if ( overTop > 0 && overBottom <= 0 ) {
1400					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1401					position.top += overTop - newOverBottom;
1402				// element is initially over bottom of within
1403				} else if ( overBottom > 0 && overTop <= 0 ) {
1404					position.top = withinOffset;
1405				// element is initially over both top and bottom of within
1406				} else {
1407					if ( overTop > overBottom ) {
1408						position.top = withinOffset + outerHeight - data.collisionHeight;
1409					} else {
1410						position.top = withinOffset;
1411					}
1412				}
1413			// too far up -> align with top
1414			} else if ( overTop > 0 ) {
1415				position.top += overTop;
1416			// too far down -> align with bottom edge
1417			} else if ( overBottom > 0 ) {
1418				position.top -= overBottom;
1419			// adjust based on position and margin
1420			} else {
1421				position.top = max( position.top - collisionPosTop, position.top );
1422			}
1423		}
1424	},
1425	flip: {
1426		left: function( position, data ) {
1427			var within = data.within,
1428				withinOffset = within.offset.left + within.scrollLeft,
1429				outerWidth = within.width,
1430				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1431				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1432				overLeft = collisionPosLeft - offsetLeft,
1433				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1434				myOffset = data.my[ 0 ] === "left" ?
1435					-data.elemWidth :
1436					data.my[ 0 ] === "right" ?
1437						data.elemWidth :
1438						0,
1439				atOffset = data.at[ 0 ] === "left" ?
1440					data.targetWidth :
1441					data.at[ 0 ] === "right" ?
1442						-data.targetWidth :
1443						0,
1444				offset = -2 * data.offset[ 0 ],
1445				newOverRight,
1446				newOverLeft;
1447
1448			if ( overLeft < 0 ) {
1449				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1450				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1451					position.left += myOffset + atOffset + offset;
1452				}
1453			} else if ( overRight > 0 ) {
1454				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1455				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1456					position.left += myOffset + atOffset + offset;
1457				}
1458			}
1459		},
1460		top: function( position, data ) {
1461			var within = data.within,
1462				withinOffset = within.offset.top + within.scrollTop,
1463				outerHeight = within.height,
1464				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1465				collisionPosTop = position.top - data.collisionPosition.marginTop,
1466				overTop = collisionPosTop - offsetTop,
1467				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1468				top = data.my[ 1 ] === "top",
1469				myOffset = top ?
1470					-data.elemHeight :
1471					data.my[ 1 ] === "bottom" ?
1472						data.elemHeight :
1473						0,
1474				atOffset = data.at[ 1 ] === "top" ?
1475					data.targetHeight :
1476					data.at[ 1 ] === "bottom" ?
1477						-data.targetHeight :
1478						0,
1479				offset = -2 * data.offset[ 1 ],
1480				newOverTop,
1481				newOverBottom;
1482			if ( overTop < 0 ) {
1483				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1484				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1485					position.top += myOffset + atOffset + offset;
1486				}
1487			} else if ( overBottom > 0 ) {
1488				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1489				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1490					position.top += myOffset + atOffset + offset;
1491				}
1492			}
1493		}
1494	},
1495	flipfit: {
1496		left: function() {
1497			$.ui.position.flip.left.apply( this, arguments );
1498			$.ui.position.fit.left.apply( this, arguments );
1499		},
1500		top: function() {
1501			$.ui.position.flip.top.apply( this, arguments );
1502			$.ui.position.fit.top.apply( this, arguments );
1503		}
1504	}
1505};
1506
1507// fraction support test
1508(function() {
1509	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1510		body = document.getElementsByTagName( "body" )[ 0 ],
1511		div = document.createElement( "div" );
1512
1513	//Create a "fake body" for testing based on method used in jQuery.support
1514	testElement = document.createElement( body ? "div" : "body" );
1515	testElementStyle = {
1516		visibility: "hidden",
1517		width: 0,
1518		height: 0,
1519		border: 0,
1520		margin: 0,
1521		background: "none"
1522	};
1523	if ( body ) {
1524		$.extend( testElementStyle, {
1525			position: "absolute",
1526			left: "-1000px",
1527			top: "-1000px"
1528		});
1529	}
1530	for ( i in testElementStyle ) {
1531		testElement.style[ i ] = testElementStyle[ i ];
1532	}
1533	testElement.appendChild( div );
1534	testElementParent = body || document.documentElement;
1535	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1536
1537	div.style.cssText = "position: absolute; left: 10.7432222px;";
1538
1539	offsetLeft = $( div ).offset().left;
1540	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1541
1542	testElement.innerHTML = "";
1543	testElementParent.removeChild( testElement );
1544})();
1545
1546})();
1547
1548var position = $.ui.position;
1549
1550
1551/*!
1552 * jQuery UI Accordion 1.11.

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

1769		// was collapsed or no panel
1770		if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1771			options.active = false;
1772			this.active = $();
1773		// active false only when collapsible is true
1774		} else if ( options.active === false ) {
1775			this._activate( 0 );
1776		// was active, but active panel is gone
1777		} else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1778			// all remaining panel are disabled
1779			if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1780				options.active = false;
1781				this.active = $();
1782			// activate previous panel
1783			} else {
1784				this._activate( Math.max( 0, options.active - 1 ) );
1785			}
1786		// was active, active panel still exists
1787		} else {
1788			// make sure active index is correct
1789			options.active = this.headers.index( this.active );
1790		}
1791
1792		this._destroyIcons();
1793
1794		this._refresh();
1795	},
1796
1797	_processPanels: function() {
1798		var prevHeaders = this.headers,
1799			prevPanels = this.panels;
1800
1801		this.headers = this.element.find( this.options.header )
1802			.addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1803
1804		this.panels = this.headers.next()
1805			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1806			.filter( ":not(.ui-accordion-content-active)" )
1807			.hide();
1808
1809		// Avoid memory leaks (#10056)
1810		if ( prevPanels ) {
1811			this._off( prevHeaders.not( this.headers ) );
1812			this._off( prevPanels.not( this.panels ) );
1813		}
1814	},
1815
1816	_refresh: function() {
1817		var maxHeight,
1818			options = this.options,
1819			heightStyle = options.heightStyle,
1820			parent = this.element.parent();
1821
1822		this.active = this._findActive( options.active )
1823			.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1824			.removeClass( "ui-corner-all" );
1825		this.active.next()
1826			.addClass( "ui-accordion-content-active" )
1827			.show();
1828
1829		this.headers
1830			.attr( "role", "tab" )
1831			.each(function() {
1832				var header = $( this ),
1833					headerId = header.uniqueId().attr( "id" ),
1834					panel = header.next(),
1835					panelId = panel.uniqueId().attr( "id" );
1836				header.attr( "aria-controls", panelId );
1837				panel.attr( "aria-labelledby", headerId );
1838			})
1839			.next()
1840				.attr( "role", "tabpanel" );
1841
1842		this.headers
1843			.not( this.active )
1844			.attr({
1845				"aria-selected": "false",
1846				"aria-expanded": "false",
1847				tabIndex: -1
1848			})
1849			.next()
1850				.attr({
1851					"aria-hidden": "true"
1852				})
1853				.hide();
1854
1855		// make sure at least one header is in the tab order
1856		if ( !this.active.length ) {
1857			this.headers.eq( 0 ).attr( "tabIndex", 0 );
1858		} else {
1859			this.active.attr({
1860				"aria-selected": "true",
1861				"aria-expanded": "true",
1862				tabIndex: 0
1863			})
1864			.next()
1865				.attr({
1866					"aria-hidden": "false"
1867				});
1868		}
1869
1870		this._createIcons();
1871
1872		this._setupEvents( options.event );
1873
1874		if ( heightStyle === "fill" ) {
1875			maxHeight = parent.height();
1876			this.element.siblings( ":visible" ).each(function() {
1877				var elem = $( this ),
1878					position = elem.css( "position" );
1879
1880				if ( position === "absolute" || position === "fixed" ) {
1881					return;
1882				}
1883				maxHeight -= elem.outerHeight( true );
1884			});
1885
1886			this.headers.each(function() {
1887				maxHeight -= $( this ).outerHeight( true );
1888			});
1889
1890			this.headers.next()
1891				.each(function() {
1892					$( this ).height( Math.max( 0, maxHeight -
1893						$( this ).innerHeight() + $( this ).height() ) );
1894				})
1895				.css( "overflow", "auto" );
1896		} else if ( heightStyle === "auto" ) {
1897			maxHeight = 0;
1898			this.headers.next()
1899				.each(function() {
1900					maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1901				})
1902				.height( maxHeight );
1903		}
1904	},
1905
1906	_activate: function( index ) {
1907		var active = this._findActive( index )[ 0 ];
1908
1909		// trying to activate the already active panel
1910		if ( active === this.active[ 0 ] ) {
1911			return;
1912		}
1913
1914		// trying to collapse, simulate a click on the currently active header
1915		active = active || this.active[ 0 ];
1916
1917		this._eventHandler({
1918			target: active,
1919			currentTarget: active,
1920			preventDefault: $.noop
1921		});
1922	},
1923
1924	_findActive: function( selector ) {
1925		return typeof selector === "number" ? this.headers.eq( selector ) : $();
1926	},
1927
1928	_setupEvents: function( event ) {
1929		var events = {
1930			keydown: "_keydown"
1931		};
1932		if ( event ) {
1933			$.each( event.split( " " ), function( index, eventName ) {
1934				events[ eventName ] = "_eventHandler";
1935			});
1936		}
1937
1938		this._off( this.headers.add( this.headers.next() ) );
1939		this._on( this.headers, events );
1940		this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1941		this._hoverable( this.headers );
1942		this._focusable( this.headers );
1943	},
1944
1945	_eventHandler: function( event ) {
1946		var options = this.options,
1947			active = this.active,
1948			clicked = $( event.currentTarget ),
1949			clickedIsActive = clicked[ 0 ] === active[ 0 ],

1950			collapsing = clickedIsActive && options.collapsible,
1951			toShow = collapsing ? $() : clicked.next(),
1952			toHide = active.next(),
1953			eventData = {
1954				oldHeader: active,
1955				oldPanel: toHide,
1956				newHeader: collapsing ? $() : clicked,
1957				newPanel: toShow
1958			};
1959
1960		event.preventDefault();
1961
1962		if (
1963				// click on active header, but not collapsible
1964				( clickedIsActive && !options.collapsible ) ||
1965				// allow canceling activation
1966				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1967			return;
1968		}
1969
1970		options.active = collapsing ? false : this.headers.index( clicked );
1971
1972		// when the call to ._toggle() comes after the class changes
1973		// it causes a very odd bug in IE 8 (see #6720)
1974		this.active = clickedIsActive ? $() : clicked;
1975		this._toggle( eventData );
1976
1977		// switch classes
1978		// corner classes on the previously active header stay after the animation
1979		active.removeClass( "ui-accordion-header-active ui-state-active" );
1980		if ( options.icons ) {
1981			active.children( ".ui-accordion-header-icon" )
1982				.removeClass( options.icons.activeHeader )
1983				.addClass( options.icons.header );
1984		}
1985
1986		if ( !clickedIsActive ) {
1987			clicked
1988				.removeClass( "ui-corner-all" )
1989				.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1990			if ( options.icons ) {
1991				clicked.children( ".ui-accordion-header-icon" )
1992					.removeClass( options.icons.header )
1993					.addClass( options.icons.activeHeader );
1994			}
1995
1996			clicked
1997				.next()
1998				.addClass( "ui-accordion-content-active" );
1999		}
2000	},
2001
2002	_toggle: function( data ) {
2003		var toShow = data.newPanel,
2004			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2005
2006		// handle activating a panel during the animation for another activation
2007		this.prevShow.add( this.prevHide ).stop( true, true );
2008		this.prevShow = toShow;
2009		this.prevHide = toHide;
2010
2011		if ( this.options.animate ) {
2012			this._animate( toShow, toHide, data );
2013		} else {
2014			toHide.hide();
2015			toShow.show();
2016			this._toggleComplete( data );
2017		}
2018
2019		toHide.attr({
2020			"aria-hidden": "true"
2021		});
2022		toHide.prev().attr( "aria-selected", "false" );
2023		// if we're switching panels, remove the old header from the tab order
2024		// if we're opening from collapsed state, remove the previous header from the tab order
2025		// if we're collapsing, then keep the collapsing header in the tab order
2026		if ( toShow.length && toHide.length ) {
2027			toHide.prev().attr({
2028				"tabIndex": -1,
2029				"aria-expanded": "false"
2030			});
2031		} else if ( toShow.length ) {
2032			this.headers.filter(function() {
2033				return $( this ).attr( "tabIndex" ) === 0;
2034			})
2035			.attr( "tabIndex", -1 );
2036		}
2037
2038		toShow
2039			.attr( "aria-hidden", "false" )
2040			.prev()
2041				.attr({
2042					"aria-selected": "true",
2043					tabIndex: 0,
2044					"aria-expanded": "true"
2045				});
2046	},
2047
2048	_animate: function( toShow, toHide, data ) {
2049		var total, easing, duration,
2050			that = this,
2051			adjust = 0,
2052			down = toShow.length &&
2053				( !toHide.length || ( toShow.index() < toHide.index() ) ),
2054			animate = this.options.animate || {},
2055			options = down && animate.down || animate,
2056			complete = function() {
2057				that._toggleComplete( data );
2058			};
2059
2060		if ( typeof options === "number" ) {
2061			duration = options;
2062		}
2063		if ( typeof options === "string" ) {
2064			easing = options;
2065		}
2066		// fall back from options to animation in case of partial down settings
2067		easing = easing || options.easing || animate.easing;
2068		duration = duration || options.duration || animate.duration;
2069
2070		if ( !toHide.length ) {
2071			return toShow.animate( this.showProps, duration, easing, complete );
2072		}
2073		if ( !toShow.length ) {
2074			return toHide.animate( this.hideProps, duration, easing, complete );
2075		}
2076
2077		total = toShow.show().outerHeight();
2078		toHide.animate( this.hideProps, {
2079			duration: duration,
2080			easing: easing,
2081			step: function( now, fx ) {
2082				fx.now = Math.round( now );
2083			}
2084		});
2085		toShow
2086			.hide()
2087			.animate( this.showProps, {
2088				duration: duration,
2089				easing: easing,
2090				complete: complete,
2091				step: function( now, fx ) {
2092					fx.now = Math.round( now );
2093					if ( fx.prop !== "height" ) {
2094						adjust += fx.now;
2095					} else if ( that.options.heightStyle !== "content" ) {
2096						fx.now = Math.round( total - toHide.outerHeight() - adjust );
2097						adjust = 0;
2098					}
2099				}
2100			});
2101	},
2102
2103	_toggleComplete: function( data ) {
2104		var toHide = data.oldPanel;
2105
2106		toHide
2107			.removeClass( "ui-accordion-content-active" )
2108			.prev()
2109				.removeClass( "ui-corner-top" )
2110				.addClass( "ui-corner-all" );
2111
2112		// Work around for rendering bug in IE (#5421)
2113		if ( toHide.length ) {
2114			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2115		}
2116		this._trigger( "activate", null, data );
2117	}
2118});
2119
2120
2121/*!
2122 * jQuery UI Menu 1.11.

2134",
2135	defaultElement: "<ul>",
2136	delay: 300,
2137	options: {
2138		icons: {
2139			submenu: "ui-icon-carat-1-e"
2140		},
2141		items: "> *",
2142		menus: "ul",
2143		position: {
2144			my: "left-1 top",
2145			at: "right top"
2146		},
2147		role: "menu",
2148
2149		// callbacks
2150		blur: null,
2151		focus: null,
2152		select: null
2153	},
2154
2155	_create: function() {
2156		this.activeMenu = this.element;
2157
2158		// Flag used to prevent firing of the click handler
2159		// as the event bubbles up through nested menus
2160		this.mouseHandled = false;
2161		this.element
2162			.uniqueId()
2163			.addClass( "ui-menu ui-widget ui-widget-content" )
2164			.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2165			.attr({
2166				role: this.options.role,
2167				tabIndex: 0
2168			});
2169
2170		if ( this.options.disabled ) {
2171			this.element
2172				.addClass( "ui-state-disabled" )
2173				.attr( "aria-disabled", "true" );
2174		}
2175
2176		this._on({
2177			// Prevent focus from sticking to links inside menu after clicking
2178			// them (focus should always stay on UL during navigation).
2179			"mousedown .ui-menu-item": function( event ) {
2180				event.preventDefault();
2181			},
2182			"click .ui-menu-item": function( event ) {
2183				var target = $( event.target );
2184				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2185					this.select( event );
2186
2187					// Only set the mouseHandled flag if the event will bubble, see #9469.
2188					if ( !event.isPropagationStopped() ) {
2189						this.mouseHandled = true;
2190					}
2191
2192					// Open submenu on click
2193					if ( target.has( ".ui-menu" ).length ) {
2194						this.expand( event );
2195					} else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2196
2197						// Redirect focus to the menu
2198						this.element.trigger( "focus", [ true ] );
2199
2200						// If the active item is on the top level, let it stay active.
2201						// Otherwise, blur the active item since it is no longer visible.
2202						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2203							clearTimeout( this.timer );
2204						}
2205					}
2206				}
2207			},
2208			"mouseenter .ui-menu-item": function( event ) {
2209				// Ignore mouse events while typeahead is active, see #10458.
2210				// Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2211				// is over an item in the menu
2212				if ( this.previousFilter ) {
2213					return;
2214				}
2215				var target = $( event.currentTarget );
2216				// Remove ui-state-active class from siblings of the newly focused menu item
2217				// to avoid a jump caused by adjacent elements both having a class with a border
2218				target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2219				this.focus( event, target );
2220			},
2221			mouseleave: "collapseAll",
2222			"mouseleave .ui-menu": "collapseAll",
2223			focus: function( event, keepActiveItem ) {
2224				// If there's already an active item, keep it active
2225				// If not, activate the first item
2226				var item = this.active || this.element.find( this.options.items ).eq( 0 );
2227
2228				if ( !keepActiveItem ) {
2229					this.focus( event, item );
2230				}
2231			},
2232			blur: function( event ) {
2233				this._delay(function() {
2234					if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2235						this.collapseAll( event );
2236					}
2237				});
2238			},
2239			keydown: "_keydown"
2240		});
2241
2242		this.refresh();
2243
2244		// Clicks outside of a menu collapse any open menus
2245		this._on( this.document, {
2246			click: function( event ) {
2247				if ( this._closeOnDocumentClick( event ) ) {
2248					this.collapseAll( event );
2249				}
2250
2251				// Reset the mouseHandled flag
2252				this.mouseHandled = false;
2253			}
2254		});
2255	},
2256
2257	_destroy: function() {
2258		// Destroy (sub)menus
2259		this.element
2260			.removeAttr( "aria-activedescendant" )
2261			.find( ".ui-menu" ).addBack()
2262				.removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2263				.removeAttr( "role" )
2264				.removeAttr( "tabIndex" )
2265				.removeAttr( "aria-labelledby" )
2266				.removeAttr( "aria-expanded" )
2267				.removeAttr( "aria-hidden" )
2268				.removeAttr( "aria-disabled" )
2269				.removeUniqueId()
2270				.show();
2271
2272		// Destroy menu items
2273		this.element.find( ".ui-menu-item" )
2274			.removeClass( "ui-menu-item" )
2275			.removeAttr( "role" )
2276			.removeAttr( "aria-disabled" )
2277			.removeUniqueId()
2278			.removeClass( "ui-state-hover" )
2279			.removeAttr( "tabIndex" )
2280			.removeAttr( "role" )
2281			.removeAttr( "aria-haspopup" )
2282			.children().each( function() {
2283				var elem = $( this );
2284				if ( elem.data( "ui-menu-submenu-carat" ) ) {
2285					elem.remove();
2286				}
2287			});
2288
2289		// Destroy menu dividers
2290		this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2291	},
2292
2293	_keydown: function( event ) {
2294		var match, prev, character, skip,
2295			preventDefault = true;
2296
2297		switch ( event.keyCode ) {
2298		case $.ui.keyCode.PAGE_UP:
2299			this.previousPage( event );
2300			break;
2301		case $.ui.keyCode.PAGE_DOWN:
2302			this.nextPage( event );
2303			break;
2304		case $.ui.keyCode.HOME:
2305			this._move( "first", "first", event );
2306			break;
2307		case $.ui.keyCode.END:
2308			this._move( "last", "last", event );
2309			break;
2310		case $.ui.keyCode.UP:
2311			this.previous( event );
2312			break;
2313		case $.ui.keyCode.DOWN:
2314			this.next( event );
2315			break;
2316		case $.ui.keyCode.LEFT:
2317			this.collapse( event );
2318			break;
2319		case $.ui.keyCode.RIGHT:
2320			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2321				this.expand( event );
2322			}
2323			break;
2324		case $.ui.keyCode.ENTER:
2325		case $.ui.keyCode.SPACE:
2326			this._activate( event );
2327			break;
2328		case $.ui.keyCode.ESCAPE:
2329			this.collapse( event );
2330			break;
2331		default:
2332			preventDefault = false;
2333			prev = this.previousFilter || "";
2334			character = String.fromCharCode( event.keyCode );
2335			skip = false;
2336
2337			clearTimeout( this.filterTimer );
2338
2339			if ( character === prev ) {
2340				skip = true;
2341			} else {
2342				character = prev + character;
2343			}
2344
2345			match = this._filterMenuItems( character );
2346			match = skip && match.index( this.active.next() ) !== -1 ?
2347				this.active.nextAll( ".ui-menu-item" ) :
2348				match;
2349
2350			// If no matches on the current filter, reset to the last character pressed
2351			// to move down the menu to the first item that starts with that character
2352			if ( !match.length ) {
2353				character = String.fromCharCode( event.keyCode );
2354				match = this._filterMenuItems( character );
2355			}
2356
2357			if ( match.length ) {
2358				this.focus( event, match );
2359				this.previousFilter = character;
2360				this.filterTimer = this._delay(function() {
2361					delete this.previousFilter;
2362				}, 1000 );
2363			} else {
2364				delete this.previousFilter;
2365			}
2366		}
2367
2368		if ( preventDefault ) {
2369			event.preventDefault();
2370		}
2371	},
2372
2373	_activate: function( event ) {
2374		if ( !this.active.is( ".ui-state-disabled" ) ) {
2375			if ( this.active.is( "[aria-haspopup='true']" ) ) {
2376				this.expand( event );
2377			} else {
2378				this.select( event );
2379			}
2380		}
2381	},
2382
2383	refresh: function() {
2384		var menus, items,
2385			that = this,
2386			icon = this.options.icons.submenu,
2387			submenus = this.element.find( this.options.menus );
2388
2389		this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2390
2391		// Initialize nested menus
2392		submenus.filter( ":not(.ui-menu)" )
2393			.addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2394			.hide()
2395			.attr({
2396				role: this.options.role,
2397				"aria-hidden": "true",
2398				"aria-expanded": "false"
2399			})
2400			.each(function() {
2401				var menu = $( this ),
2402					item = menu.parent(),
2403					submenuCarat = $( "<span>" )
2404						.addClass( "ui-menu-icon ui-icon " + icon )
2405						.data( "ui-menu-submenu-carat", true );
2406
2407				item
2408					.attr( "aria-haspopup", "true" )
2409					.prepend( submenuCarat );
2410				menu.attr( "aria-labelledby", item.attr( "id" ) );
2411			});
2412
2413		menus = submenus.add( this.element );
2414		items = menus.find( this.options.items );
2415

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

2568			// If we were passed an event, look for the submenu that contains the event
2569			var currentMenu = all ? this.element :
2570				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2571
2572			// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2573			if ( !currentMenu.length ) {
2574				currentMenu = this.element;
2575			}
2576
2577			this._close( currentMenu );
2578
2579			this.blur( event );
2580			this.activeMenu = currentMenu;
2581		}, this.delay );
2582	},
2583
2584	// With no arguments, closes the currently active menu - if nothing is active
2585	// it closes all menus.  If passed an argument, it will search for menus BELOW
2586	_close: function( startMenu ) {
2587		if ( !startMenu ) {
2588			startMenu = this.active ? this.active.parent() : this.element;
2589		}
2590
2591		startMenu
2592			.find( ".ui-menu" )
2593				.hide()
2594				.attr( "aria-hidden", "true" )
2595				.attr( "aria-expanded", "false" )
2596			.end()
2597			.find( ".ui-state-active" ).not( ".ui-state-focus" )
2598				.removeClass( "ui-state-active" );
2599	},
2600
2601	_closeOnDocumentClick: function( event ) {
2602		return !$( event.target ).closest( ".ui-menu" ).length;
2603	},
2604
2605	_isDivider: function( item ) {
2606
2607		// Match hyphen, em dash, en dash
2608		return !/[^\-\u2014\u2013\s]/.test( item.text() );
2609	},
2610
2611	collapse: function( event ) {
2612		var newItem = this.active &&
2613			this.active.parent().closest( ".ui-menu-item", this.element );
2614		if ( newItem && newItem.length ) {
2615			this._close();
2616			this.focus( event, newItem );
2617		}
2618	},
2619
2620	expand: function( event ) {
2621		var newItem = this.active &&
2622			this.active
2623				.children( ".ui-menu " )
2624				.find( this.options.items )
2625				.first();
2626
2627		if ( newItem && newItem.length ) {
2628			this._open( newItem.parent() );
2629
2630			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2631			this._delay(function() {
2632				this.focus( event, newItem );
2633			});
2634		}
2635	},
2636
2637	next: function( event ) {
2638		this._move( "next", "first", event );
2639	},
2640
2641	previous: function( event ) {
2642		this._move( "prev", "last", event );
2643	},
2644
2645	isFirstItem: function() {
2646		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2647	},
2648
2649	isLastItem: function() {
2650		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2651	},
2652
2653	_move: function( direction, filter, event ) {
2654		var next;
2655		if ( this.active ) {
2656			if ( direction === "first" || direction === "last" ) {
2657				next = this.active
2658					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2659					.eq( -1 );
2660			} else {
2661				next = this.active
2662					[ direction + "All" ]( ".ui-menu-item" )
2663					.eq( 0 );
2664			}
2665		}
2666		if ( !next || !next.length || !this.active ) {
2667			next = this.activeMenu.find( this.options.items )[ filter ]();
2668		}
2669
2670		this.focus( event, next );
2671	},
2672
2673	nextPage: function( event ) {
2674		var item, base, height;
2675
2676		if ( !this.active ) {
2677			this.next( event );
2678			return;
2679		}
2680		if ( this.isLastItem() ) {
2681			return;
2682		}
2683		if ( this._hasScroll() ) {
2684			base = this.active.offset().top;
2685			height = this.element.height();
2686			this.active.nextAll( ".ui-menu-item" ).each(function() {
2687				item = $( this );
2688				return item.offset().top - base - height < 0;
2689			});
2690
2691			this.focus( event, item );
2692		} else {
2693			this.focus( event, this.activeMenu.find( this.options.items )
2694				[ !this.active ? "first" : "last" ]() );
2695		}
2696	},
2697
2698	previousPage: function( event ) {
2699		var item, base, height;
2700		if ( !this.active ) {
2701			this.next( event );
2702			return;
2703		}
2704		if ( this.isFirstItem() ) {
2705			return;
2706		}
2707		if ( this._hasScroll() ) {
2708			base = this.active.offset().top;
2709			height = this.element.height();
2710			this.active.prevAll( ".ui-menu-item" ).each(function() {
2711				item = $( this );
2712				return item.offset().top - base + height > 0;
2713			});
2714
2715			this.focus( event, item );
2716		} else {
2717			this.focus( event, this.activeMenu.find( this.options.items ).first() );
2718		}
2719	},
2720
2721	_hasScroll: function() {
2722		return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2723	},
2724
2725	select: function( event ) {
2726		// TODO: It should never be possible to not have an active item at this
2727		// point, but the tests don't trigger mouseenter before click.
2728		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2729		var ui = { item: this.active };
2730		if ( !this.active.has( ".ui-menu" ).length ) {
2731			this.collapseAll( event, true );
2732		}
2733		this._trigger( "select", event, ui );
2734	},
2735
2736	_filterMenuItems: function(character) {
2737		var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2738			regex = new RegExp( "^" + escapedCharacter, "i" );
2739
2740		return this.activeMenu
2741			.find( this.options.items )
2742
2743			// Only match on items, not dividers or other content (#10571)
2744			.filter( ".ui-menu-item" )
2745			.filter(function() {
2746				return regex.test( $.trim( $( this ).text() ) );
2747			});
2748	}
2749});
2750
2751
2752/*!
2753 * jQuery UI Autocomplete 1.11.