https://fearless.fr/wp-content/plugins/grid-plus/assets/lib/grid-stack/jquery-ui.js?ver=6.5.12

1/*! jQuery UI - v1.11.0 - 2014-06-26
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.0
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.0",
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() {
58		var position = this.css( "position" ),
59			excludeStaticParent = position === "absolute",
60			scrollParent = this.parents().filter( function() {
61				var parent = $( this );
62				if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
63					return false;
64				}
65				return (/(auto|scroll)/).test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
66			}).eq( 0 );
67
68		return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
69	},
70
71	uniqueId: (function() {
72		var uuid = 0;
73
74		return function() {
75			return this.each(function() {
76				if ( !this.id ) {
77					this.id = "ui-id-" + ( ++uuid );
78				}
79			});
80		};
81	})(),
82
83	removeUniqueId: function() {
84		return this.each(function() {
85			if ( /^ui-id-\d+$/.test( this.id ) ) {
86				$( this ).removeAttr( "id" );
87			}
88		});
89	}
90});
91
92// selectors
93function focusable( element, isTabIndexNotNaN ) {
94	var map, mapName, img,
95		nodeName = element.nodeName.toLowerCase();
96	if ( "area" === nodeName ) {
97		map = element.parentNode;
98		mapName = map.name;
99		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
100			return false;
101		}
102		img = $( "img[usemap=#" + mapName + "]" )[0];
103		return !!img && visible( img );
104	}
105	return ( /input|select|textarea|button|object/.test( nodeName ) ?
106		!element.disabled :
107		"a" === nodeName ?
108			element.href || isTabIndexNotNaN :
109			isTabIndexNotNaN) &&
110		// the element and all of its ancestors must be visible
111		visible( element );
112}
113
114function visible( element ) {
115	return $.expr.filters.visible( element ) &&
116		!$( element ).parents().addBack().filter(function() {
117			return $.css( this, "visibility" ) === "hidden";
118		}).length;
119}
120
121$.extend( $.expr[ ":" ], {
122	data: $.expr.createPseudo ?
123		$.expr.createPseudo(function( dataName ) {
124			return function( elem ) {
125				return !!$.data( elem, dataName );
126			};
127		}) :
128		// support: jQuery <1.8
129		function( elem, i, match ) {
130			return !!$.data( elem, match[ 3 ] );
131		},
132
133	focusable: function( element ) {
134		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
135	},
136
137	tabbable: function( element ) {
138		var tabIndex = $.attr( element, "tabindex" ),
139			isTabIndexNaN = isNaN( tabIndex );
140		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
141	}
142});
143
144// support: jQuery <1.8
145if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
146	$.each( [ "Width", "Height" ], function( i, name ) {
147		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
148			type = name.toLowerCase(),
149			orig = {
150				innerWidth: $.fn.innerWidth,
151				innerHeight: $.fn.innerHeight,
152				outerWidth: $.fn.outerWidth,
153				outerHeight: $.fn.outerHeight
154			};
155
156		function reduce( elem, size, border, margin ) {
157			$.each( side, function() {
158				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
159				if ( border ) {
160					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
161				}
162				if ( margin ) {
163					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
164				}
165			});
166			return size;
167		}
168
169		$.fn[ "inner" + name ] = function( size ) {
170			if ( size === undefined ) {
171				return orig[ "inner" + name ].call( this );
172			}
173
174			return this.each(function() {
175				$( this ).css( type, reduce( this, size ) + "px" );
176			});
177		};
178
179		$.fn[ "outer" + name] = function( size, margin ) {
180			if ( typeof size !== "number" ) {
181				return orig[ "outer" + name ].call( this, size );
182			}
183
184			return this.each(function() {
185				$( this).css( type, reduce( this, size, true, margin ) + "px" );
186			});
187		};
188	});
189}
190
191// support: jQuery <1.8
192if ( !$.fn.addBack ) {
193	$.fn.addBack = function( selector ) {
194		return this.add( selector == null ?
195			this.prevObject : this.prevObject.filter( selector )
196		);
197	};
198}
199
200// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
201if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
202	$.fn.removeData = (function( removeData ) {
203		return function( key ) {
204			if ( arguments.length ) {
205				return removeData.call( this, $.camelCase( key ) );
206			} else {
207				return removeData.call( this );
208			}
209		};
210	})( $.fn.removeData );
211}
212
213// deprecated
214$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
215
216$.fn.extend({
217	focus: (function( orig ) {
218		return function( delay, fn ) {
219			return typeof delay === "number" ?
220				this.each(function() {
221					var elem = this;
222					setTimeout(function() {
223						$( elem ).focus();
224						if ( fn ) {
225							fn.call( elem );
226						}
227					}, delay );
228				}) :
229				orig.apply( this, arguments );
230		};
231	})( $.fn.focus ),
232
233	disableSelection: (function() {
234		var eventType = "onselectstart" in document.createElement( "div" ) ?
235			"selectstart" :
236			"mousedown";
237
238		return function() {
239			return this.bind( eventType + ".ui-disableSelection", function( event ) {
240				event.preventDefault();
241			});
242		};
243	})(),
244
245	enableSelection: function() {
246		return this.unbind( ".ui-disableSelection" );
247	},
248
249	zIndex: function( zIndex ) {
250		if ( zIndex !== undefined ) {
251			return this.css( "zIndex", zIndex );
252		}
253
254		if ( this.length ) {
255			var elem = $( this[ 0 ] ), position, value;
256			while ( elem.length && elem[ 0 ] !== document ) {
257				// Ignore z-index if position is set to a value where z-index is ignored by the browser
258				// This makes behavior of this function consistent across browsers
259				// WebKit always returns auto if the element is positioned
260				position = elem.css( "position" );
261				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
262					// IE returns 0 when zIndex is not specified
263					// other browsers return a string
264					// we ignore the case of nested elements with an explicit value of 0
265					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
266					value = parseInt( elem.css( "zIndex" ), 10 );
267					if ( !isNaN( value ) && value !== 0 ) {
268						return value;
269					}
270				}
271				elem = elem.parent();
272			}
273		}
274
275		return 0;
276	}
277});
278
279// $.ui.plugin is deprecated. Use $.widget() extensions instead.
280$.ui.plugin = {
281	add: function( module, option, set ) {
282		var i,
283			proto = $.ui[ module ].prototype;
284		for ( i in set ) {
285			proto.plugins[ i ] = proto.plugins[ i ] || [];
286			proto.plugins[ i ].push( [ option, set[ i ] ] );
287		}
288	},
289	call: function( instance, name, args, allowDisconnected ) {
290		var i,
291			set = instance.plugins[ name ];
292
293		if ( !set ) {
294			return;
295		}
296
297		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
298			return;
299		}
300
301		for ( i = 0; i < set.length; i++ ) {
302			if ( instance.options[ set[ i ][ 0 ] ] ) {
303				set[ i ][ 1 ].apply( instance.element, args );
304			}
305		}
306	}
307};
308
309
310/*!
311 * jQuery UI Widget 1.11.0
312 * http://jqueryui.com
313 *
314 * Copyright 2014 jQuery Foundation and other contributors
315 * Released under the MIT license.
316 * http://jquery.org/license
317 *
318 * http://api.jqueryui.com/jQuery.widget/
319 */
320
321
322var widget_uuid = 0,
323	widget_slice = Array.prototype.slice;
324
325$.cleanData = (function( orig ) {
326	return function( elems ) {
327		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
328			try {
329				$( elem ).triggerHandler( "remove" );

329
330			// http://bugs.jquery.com/ticket/8235
331			} catch( e ) {}
332		}
333		orig( elems );
334	};
335})( $.cleanData );
336
337$.widget = function( name, base, prototype ) {
338	var fullName, existingConstructor, constructor, basePrototype,
339		// proxiedPrototype allows the provided prototype to remain unmodified
340		// so that it can be used as a mixin for multiple widgets (#8876)
341		proxiedPrototype = {},
342		namespace = name.split( "." )[ 0 ];
343
344	name = name.split( "." )[ 1 ];
345	fullName = namespace + "-" + name;
346
347	if ( !prototype ) {
348		prototype = base;
349		base = $.Widget;
350	}
351
352	// create selector for plugin
353	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
354		return !!$.data( elem, fullName );
355	};
356
357	$[ namespace ] = $[ namespace ] || {};
358	existingConstructor = $[ namespace ][ name ];
359	constructor = $[ namespace ][ name ] = function( options, element ) {
360		// allow instantiation without "new" keyword
361		if ( !this._createWidget ) {
362			return new constructor( options, element );
363		}
364
365		// allow instantiation without initializing for simple inheritance
366		// must use "new" keyword (the code above always passes args)
367		if ( arguments.length ) {
368			this._createWidget( options, element );
369		}
370	};
371	// extend with the existing constructor to carry over any static properties
372	$.extend( constructor, existingConstructor, {
373		version: prototype.version,
374		// copy the object used to create the prototype in case we need to
375		// redefine the widget later
376		_proto: $.extend( {}, prototype ),
377		// track widgets that inherit from this widget in case this widget is
378		// redefined after a widget inherits from it
379		_childConstructors: []
380	});
381
382	basePrototype = new base();
383	// we need to make the options hash a property directly on the new instance
384	// otherwise we'll modify the options hash on the prototype that we're
385	// inheriting from
386	basePrototype.options = $.widget.extend( {}, basePrototype.options );
387	$.each( prototype, function( prop, value ) {
388		if ( !$.isFunction( value ) ) {
389			proxiedPrototype[ prop ] = value;
390			return;
391		}
392		proxiedPrototype[ prop ] = (function() {
393			var _super = function() {
394					return base.prototype[ prop ].apply( this, arguments );
395				},
396				_superApply = function( args ) {
397					return base.prototype[ prop ].apply( this, args );
398				};
399			return function() {
400				var __super = this._super,
401					__superApply = this._superApply,
402					returnValue;
403
404				this._super = _super;
405				this._superApply = _superApply;
406
407				returnValue = value.apply( this, arguments );
408
409				this._super = __super;
410				this._superApply = __superApply;
411
412				return returnValue;
413			};
414		})();
415	});
416	constructor.prototype = $.widget.extend( basePrototype, {
417		// TODO: remove support for widgetEventPrefix
418		// always use the name + a colon as the prefix, e.g., draggable:start
419		// don't prefix for widgets that aren't DOM-based
420		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
421	}, proxiedPrototype, {
422		constructor: constructor,
423		namespace: namespace,
424		widgetName: name,
425		widgetFullName: fullName
426	});
427
428	// If this widget is being redefined then we need to find all widgets that
429	// are inheriting from it and redefine all of them so that they inherit from
430	// the new version of this widget. We're essentially trying to replace one
431	// level in the prototype chain.
432	if ( existingConstructor ) {
433		$.each( existingConstructor._childConstructors, function( i, child ) {
434			var childPrototype = child.prototype;
435
436			// redefine the child widget using the same prototype that was
437			// originally used, but inherit from the new version of the base
438			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
439		});
440		// remove the list of existing child constructors from the old constructor
441		// so the old child constructors can be garbage collected
442		delete existingConstructor._childConstructors;
443	} else {
444		base._childConstructors.push( constructor );
445	}
446
447	$.widget.bridge( name, constructor );
448
449	return constructor;
450};
451
452$.widget.extend = function( target ) {
453	var input = widget_slice.call( arguments, 1 ),
454		inputIndex = 0,
455		inputLength = input.length,
456		key,
457		value;
458	for ( ; inputIndex < inputLength; inputIndex++ ) {
459		for ( key in input[ inputIndex ] ) {
460			value = input[ inputIndex ][ key ];
461			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
462				// Clone objects
463				if ( $.isPlainObject( value ) ) {
464					target[ key ] = $.isPlainObject( target[ key ] ) ?
465						$.widget.extend( {}, target[ key ], value ) :
466						// Don't extend strings, arrays, etc. with objects
467						$.widget.extend( {}, value );
468				// Copy everything else by reference
469				} else {
470					target[ key ] = value;
471				}
472			}
473		}
474	}
475	return target;
476};
477
478$.widget.bridge = function( name, object ) {
479	var fullName = object.prototype.widgetFullName || name;
480	$.fn[ name ] = function( options ) {
481		var isMethodCall = typeof options === "string",
482			args = widget_slice.call( arguments, 1 ),
483			returnValue = this;
484
485		// allow multiple hashes to be passed on init
486		options = !isMethodCall && args.length ?
487			$.widget.extend.apply( null, [ options ].concat(args) ) :
488			options;
489
490		if ( isMethodCall ) {
491			this.each(function() {
492				var methodValue,
493					instance = $.data( this, fullName );
494				if ( options === "instance" ) {
495					returnValue = instance;
496					return false;
497				}
498				if ( !instance ) {
499					return $.error( "cannot call methods on " + name + " prior to initialization; " +
500						"attempted to call method '" + options + "'" );
501				}
502				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
503					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
504				}
505				methodValue = instance[ options ].apply( instance, args );
506				if ( methodValue !== instance && methodValue !== undefined ) {
507					returnValue = methodValue && methodValue.jquery ?
508						returnValue.pushStack( methodValue.get() ) :
509						methodValue;
510					return false;
511				}
512			});
513		} else {
514			this.each(function() {
515				var instance = $.data( this, fullName );
516				if ( instance ) {
517					instance.option( options || {} );
518					if ( instance._init ) {
519						instance._init();
520					}
521				} else {
522					$.data( this, fullName, new object( options, this ) );
523				}
524			});
525		}
526
527		return returnValue;
528	};
529};
530
531$.Widget = function( /* options, element */ ) {};
532$.Widget._childConstructors = [];
533
534$.Widget.prototype = {
535	widgetName: "widget",
536	widgetEventPrefix: "",
537	defaultElement: "<div>",
538	options: {
539		disabled: false,
540
541		// callbacks
542		create: null
543	},
544	_createWidget: function( options, element ) {
545		element = $( element || this.defaultElement || this )[ 0 ];
546		this.element = $( element );
547		this.uuid = widget_uuid++;
548		this.eventNamespace = "." + this.widgetName + this.uuid;
549		this.options = $.widget.extend( {},
550			this.options,
551			this._getCreateOptions(),
552			options );
553
554		this.bindings = $();
555		this.hoverable = $();
556		this.focusable = $();
557
558		if ( element !== this ) {
559			$.data( element, this.widgetFullName, this );
560			this._on( true, this.element, {
561				remove: function( event ) {
562					if ( event.target === element ) {
563						this.destroy();
564					}
565				}
566			});
567			this.document = $( element.style ?
568				// element within the document
569				element.ownerDocument :
570				// element is window or document
571				element.document || element );
572			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
573		}
574
575		this._create();
576		this._trigger( "create", null, this._getCreateEventData() );
577		this._init();
578	},
579	_getCreateOptions: $.noop,
580	_getCreateEventData: $.noop,
581	_create: $.noop,
582	_init: $.noop,
583
584	destroy: function() {
585		this._destroy();
586		// we can probably remove the unbind calls in 2.0
587		// all event bindings should go through this._on()
588		this.element
589			.unbind( this.eventNamespace )
590			.removeData( this.widgetFullName )
591			// support: jquery <1.6.3
592			// http://bugs.jquery.com/ticket/9413
593			.removeData( $.camelCase( this.widgetFullName ) );
594		this.widget()
595			.unbind( this.eventNamespace )
596			.removeAttr( "aria-disabled" )
597			.removeClass(
598				this.widgetFullName + "-disabled " +
599				"ui-state-disabled" );
600
601		// clean up events and states
602		this.bindings.unbind( this.eventNamespace );
603		this.hoverable.removeClass( "ui-state-hover" );
604		this.focusable.removeClass( "ui-state-focus" );
605	},
606	_destroy: $.noop,
607
608	widget: function() {
609		return this.element;
610	},
611
612	option: function( key, value ) {
613		var options = key,
614			parts,
615			curOption,
616			i;
617
618		if ( arguments.length === 0 ) {
619			// don't return a reference to the internal hash
620			return $.widget.extend( {}, this.options );
621		}
622
623		if ( typeof key === "string" ) {
624			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
625			options = {};
626			parts = key.split( "." );
627			key = parts.shift();
628			if ( parts.length ) {
629				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
630				for ( i = 0; i < parts.length - 1; i++ ) {
631					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
632					curOption = curOption[ parts[ i ] ];
633				}
634				key = parts.pop();
635				if ( arguments.length === 1 ) {
636					return curOption[ key ] === undefined ? null : curOption[ key ];
637				}
638				curOption[ key ] = value;
639			} else {
640				if ( arguments.length === 1 ) {
641					return this.options[ key ] === undefined ? null : this.options[ key ];
642				}
643				options[ key ] = value;
644			}
645		}
646
647		this._setOptions( options );
648
649		return this;
650	},
651	_setOptions: function( options ) {
652		var key;
653
654		for ( key in options ) {
655			this._setOption( key, options[ key ] );
656		}
657
658		return this;
659	},
660	_setOption: function( key, value ) {
661		this.options[ key ] = value;
662
663		if ( key === "disabled" ) {
664			this.widget()
665				.toggleClass( this.widgetFullName + "-disabled", !!value );
666
667			// If the widget is becoming disabled, then nothing is interactive
668			if ( value ) {
669				this.hoverable.removeClass( "ui-state-hover" );
670				this.focusable.removeClass( "ui-state-focus" );
671			}
672		}
673
674		return this;
675	},
676
677	enable: function() {
678		return this._setOptions({ disabled: false });
679	},
680	disable: function() {
681		return this._setOptions({ disabled: true });
682	},
683
684	_on: function( suppressDisabledCheck, element, handlers ) {
685		var delegateElement,
686			instance = this;
687
688		// no suppressDisabledCheck flag, shuffle arguments
689		if ( typeof suppressDisabledCheck !== "boolean" ) {
690			handlers = element;
691			element = suppressDisabledCheck;
692			suppressDisabledCheck = false;
693		}
694
695		// no element argument, shuffle and use this.element
696		if ( !handlers ) {
697			handlers = element;
698			element = this.element;
699			delegateElement = this.widget();
700		} else {
701			element = delegateElement = $( element );
702			this.bindings = this.bindings.add( element );
703		}
704
705		$.each( handlers, function( event, handler ) {
706			function handlerProxy() {
707				// allow widgets to customize the disabled handling
708				// - disabled as an array instead of boolean
709				// - disabled class as method for disabling individual parts
710				if ( !suppressDisabledCheck &&
711						( instance.options.disabled === true ||
712							$( this ).hasClass( "ui-state-disabled" ) ) ) {
713					return;
714				}
715				return ( typeof handler === "string" ? instance[ handler ] : handler )
716					.apply( instance, arguments );
717			}
718
719			// copy the guid so direct unbinding works
720			if ( typeof handler !== "string" ) {
721				handlerProxy.guid = handler.guid =
722					handler.guid || handlerProxy.guid || $.guid++;
723			}
724
725			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
726				eventName = match[1] + instance.eventNamespace,
727				selector = match[2];
728			if ( selector ) {
729				delegateElement.delegate( selector, eventName, handlerProxy );
730			} else {
731				element.bind( eventName, handlerProxy );
732			}
733		});
734	},
735
736	_off: function( element, eventName ) {
737		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
738		element.unbind( eventName ).undelegate( eventName );
739	},
740
741	_delay: function( handler, delay ) {
742		function handlerProxy() {
743			return ( typeof handler === "string" ? instance[ handler ] : handler )
744				.apply( instance, arguments );
745		}
746		var instance = this;
747		return setTimeout( handlerProxy, delay || 0 );
748	},
749
750	_hoverable: function( element ) {
751		this.hoverable = this.hoverable.add( element );
752		this._on( element, {
753			mouseenter: function( event ) {
754				$( event.currentTarget ).addClass( "ui-state-hover" );
755			},
756			mouseleave: function( event ) {
757				$( event.currentTarget ).removeClass( "ui-state-hover" );
758			}
759		});
760	},
761
762	_focusable: function( element ) {
763		this.focusable = this.focusable.add( element );
764		this._on( element, {
765			focusin: function( event ) {
766				$( event.currentTarget ).addClass( "ui-state-focus" );
767			},
768			focusout: function( event ) {
769				$( event.currentTarget ).removeClass( "ui-state-focus" );
770			}
771		});
772	},
773
774	_trigger: function( type, event, data ) {
775		var prop, orig,
776			callback = this.options[ type ];
777
778		data = data || {};
779		event = $.Event( event );
780		event.type = ( type === this.widgetEventPrefix ?
781			type :
782			this.widgetEventPrefix + type ).toLowerCase();
783		// the original event may come from any element
784		// so we need to reset the target on the new event
785		event.target = this.element[ 0 ];
786
787		// copy original event properties over to the new event
788		orig = event.originalEvent;
789		if ( orig ) {
790			for ( prop in orig ) {
791				if ( !( prop in event ) ) {
792					event[ prop ] = orig[ prop ];
793				}
794			}
795		}
796
797		this.element.trigger( event, data );
798		return !( $.isFunction( callback ) &&
799			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
800			event.isDefaultPrevented() );
801	}
802};
803
804$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
805	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
806		if ( typeof options === "string" ) {
807			options = { effect: options };
808		}
809		var hasOptions,
810			effectName = !options ?
811				method :
812				options === true || typeof options === "number" ?
813					defaultEffect :
814					options.effect || defaultEffect;
815		options = options || {};
816		if ( typeof options === "number" ) {
817			options = { duration: options };
818		}
819		hasOptions = !$.isEmptyObject( options );
820		options.complete = callback;
821		if ( options.delay ) {
822			element.delay( options.delay );
823		}
824		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
825			element[ method ]( options );
826		} else if ( effectName !== method && element[ effectName ] ) {
827			element[ effectName ]( options.duration, options.easing, callback );
828		} else {
829			element.queue(function( next ) {
830				$( this )[ method ]();
831				if ( callback ) {
832					callback.call( element[ 0 ] );
833				}
834				next();
835			});
836		}
837	};
838});
839
840var widget = $.widget;
841
842
843/*!
844 * jQuery UI Mouse 1.11.

8440
845 * http://jqueryui.com
846 *
847 * Copyright 2014 jQuery Foundation and other contributors
848 * Released under the MIT license.
849 * http://jquery.org/license
850 *
851 * http://api.jqueryui.com/mouse/
852 */
853
854
855var mouseHandled = false;
856$( document ).mouseup( function() {
857	mouseHandled = false;
858});
859
860var mouse = $.widget("ui.mouse", {
861	version: "1.11.0",
862	options: {
863		cancel: "input,textarea,button,select,option",
864		distance: 1,
865		delay: 0
866	},
867	_mouseInit: function() {
868		var that = this;
869
870		this.element
871			.bind("mousedown." + this.widgetName, function(event) {
872				return that._mouseDown(event);
873			})
874			.bind("click." + this.widgetName, function(event) {
875				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
876					$.removeData(event.target, that.widgetName + ".preventClickEvent");
877					event.stopImmediatePropagation();
878					return false;
879				}
880			});
881
882		this.started = false;
883	},
884
885	// TODO: make sure destroying one instance of mouse doesn't mess with
886	// other instances of mouse
887	_mouseDestroy: function() {
888		this.element.unbind("." + this.widgetName);
889		if ( this._mouseMoveDelegate ) {
890			this.document
891				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
892				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
893		}
894	},
895
896	_mouseDown: function(event) {
897		// don't let more than one widget handle mouseStart
898		if ( mouseHandled ) {
899			return;
900		}
901
902		// we may have missed mouseup (out of window)
903		(this._mouseStarted && this._mouseUp(event));
904
905		this._mouseDownEvent = event;
906
907		var that = this,
908			btnIsLeft = (event.which === 1),
909			// event.target.nodeName works around a bug in IE 8 with
910			// disabled inputs (#7620)
911			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
912		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
913			return true;
914		}
915
916		this.mouseDelayMet = !this.options.delay;
917		if (!this.mouseDelayMet) {
918			this._mouseDelayTimer = setTimeout(function() {
919				that.mouseDelayMet = true;
920			}, this.options.delay);
921		}
922
923		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
924			this._mouseStarted = (this._mouseStart(event) !== false);
925			if (!this._mouseStarted) {
926				event.preventDefault();
927				return true;
928			}
929		}
930
931		// Click event may never have fired (Gecko & Opera)
932		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
933			$.removeData(event.target, this.widgetName + ".preventClickEvent");
934		}
935
936		// these delegates are required to keep context
937		this._mouseMoveDelegate = function(event) {
938			return that._mouseMove(event);
939		};
940		this._mouseUpDelegate = function(event) {
941			return that._mouseUp(event);
942		};
943
944		this.document
945			.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
946			.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
947
948		event.preventDefault();
949
950		mouseHandled = true;
951		return true;
952	},
953
954	_mouseMove: function(event) {
955		// IE mouseup check - mouseup happened when mouse was out of window
956		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
957			return this._mouseUp(event);
958
959		// Iframe mouseup check - mouseup occurred in another document
960		} else if ( !event.which ) {
961			return this._mouseUp( event );
962		}
963
964		if (this._mouseStarted) {
965			this._mouseDrag(event);
966			return event.preventDefault();
967		}
968
969		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
970			this._mouseStarted =
971				(this._mouseStart(this._mouseDownEvent, event) !== false);
972			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
973		}
974
975		return !this._mouseStarted;
976	},
977
978	_mouseUp: function(event) {
979		this.document
980			.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
981			.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
982
983		if (this._mouseStarted) {
984			this._mouseStarted = false;
985
986			if (event.target === this._mouseDownEvent.target) {
987				$.data(event.target, this.widgetName + ".preventClickEvent", true);
988			}
989
990			this._mouseStop(event);
991		}
992
993		mouseHandled = false;
994		return false;
995	},
996
997	_mouseDistanceMet: function(event) {
998		return (Math.max(
999				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1000				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1001			) >= this.options.distance
1002		);
1003	},
1004
1005	_mouseDelayMet: function(/* event */) {
1006		return this.mouseDelayMet;
1007	},
1008
1009	// These are placeholder methods, to be overriden by extending plugin
1010	_mouseStart: function(/* event */) {},
1011	_mouseDrag: function(/* event */) {},
1012	_mouseStop: function(/* event */) {},
1013	_mouseCapture: function(/* event */) { return true; }
1014});
1015
1016
1017/*!
1018 * jQuery UI Position 1.11.0
1019 * http://jqueryui.com
1020 *
1021 * Copyright 2014 jQuery Foundation and other contributors
1022 * Released under the MIT license.
1023 * http://jquery.org/license
1024 *
1025 * http://api.jqueryui.com/position/
1026 */
1027
1028(function() {
1029
1030$.ui = $.ui || {};
1031
1032var cachedScrollbarWidth, supportsOffsetFractions,
1033	max = Math.max,
1034	abs = Math.abs,
1035	round = Math.round,
1036	rhorizontal = /left|center|right/,
1037	rvertical = /top|center|bottom/,
1038	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1039	rposition = /^\w+/,
1040	rpercent = /%$/,
1041	_position = $.fn.position;
1042
1043function getOffsets( offsets, width, height ) {
1044	return [
1045		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1046		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1047	];
1048}
1049
1050function parseCss( element, property ) {
1051	return parseInt( $.css( element, property ), 10 ) || 0;
1052}
1053
1054function getDimensions( elem ) {
1055	var raw = elem[0];
1056	if ( raw.nodeType === 9 ) {
1057		return {
1058			width: elem.width(),
1059			height: elem.height(),
1060			offset: { top: 0, left: 0 }
1061		};
1062	}
1063	if ( $.isWindow( raw ) ) {
1064		return {
1065			width: elem.width(),
1066			height: elem.height(),
1067			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1068		};
1069	}
1070	if ( raw.preventDefault ) {
1071		return {
1072			width: 0,
1073			height: 0,
1074			offset: { top: raw.pageY, left: raw.pageX }
1075		};
1076	}
1077	return {
1078		width: elem.outerWidth(),
1079		height: elem.outerHeight(),
1080		offset: elem.offset()
1081	};
1082}
1083
1084$.position = {
1085	scrollbarWidth: function() {
1086		if ( cachedScrollbarWidth !== undefined ) {
1087			return cachedScrollbarWidth;
1088		}
1089		var w1, w2,
1090			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1091			innerDiv = div.children()[0];
1092
1093		$( "body" ).append( div );
1094		w1 = innerDiv.offsetWidth;
1095		div.css( "overflow", "scroll" );
1096
1097		w2 = innerDiv.offsetWidth;
1098
1099		if ( w1 === w2 ) {
1100			w2 = div[0].clientWidth;
1101		}
1102
1103		div.remove();
1104
1105		return (cachedScrollbarWidth = w1 - w2);
1106	},
1107	getScrollInfo: function( within ) {
1108		var overflowX = within.isWindow || within.isDocument ? "" :
1109				within.element.css( "overflow-x" ),
1110			overflowY = within.isWindow || within.isDocument ? "" :
1111				within.element.css( "overflow-y" ),
1112			hasOverflowX = overflowX === "scroll" ||
1113				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1114			hasOverflowY = overflowY === "scroll" ||
1115				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1116		return {
1117			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1118			height: hasOverflowX ? $.position.scrollbarWidth() : 0
1119		};
1120	},
1121	getWithinInfo: function( element ) {
1122		var withinElement = $( element || window ),
1123			isWindow = $.isWindow( withinElement[0] ),
1124			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1125		return {
1126			element: withinElement,
1127			isWindow: isWindow,
1128			isDocument: isDocument,
1129			offset: withinElement.offset() || { left: 0, top: 0 },
1130			scrollLeft: withinElement.scrollLeft(),
1131			scrollTop: withinElement.scrollTop(),
1132			width: isWindow ? withinElement.width() : withinElement.outerWidth(),
1133			height: isWindow

1133 ? withinElement.height() : withinElement.outerHeight()
1134		};
1135	}
1136};
1137
1138$.fn.position = function( options ) {
1139	if ( !options || !options.of ) {
1140		return _position.apply( this, arguments );
1141	}
1142
1143	// make a copy, we don't want to modify arguments
1144	options = $.extend( {}, options );
1145
1146	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1147		target = $( options.of ),
1148		within = $.position.getWithinInfo( options.within ),
1149		scrollInfo = $.position.getScrollInfo( within ),
1150		collision = ( options.collision || "flip" ).split( " " ),
1151		offsets = {};
1152
1153	dimensions = getDimensions( target );
1154	if ( target[0].preventDefault ) {
1155		// force left top to allow flipping
1156		options.at = "left top";
1157	}
1158	targetWidth = dimensions.width;
1159	targetHeight = dimensions.height;
1160	targetOffset = dimensions.offset;
1161	// clone to reuse original targetOffset later
1162	basePosition = $.extend( {}, targetOffset );
1163
1164	// force my and at to have valid horizontal and vertical positions
1165	// if a value is missing or invalid, it will be converted to center
1166	$.each( [ "my", "at" ], function() {
1167		var pos = ( options[ this ] || "" ).split( " " ),
1168			horizontalOffset,
1169			verticalOffset;
1170
1171		if ( pos.length === 1) {
1172			pos = rhorizontal.test( pos[ 0 ] ) ?
1173				pos.concat( [ "center" ] ) :
1174				rvertical.test( pos[ 0 ] ) ?
1175					[ "center" ].concat( pos ) :
1176					[ "center", "center" ];
1177		}
1178		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1179		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1180
1181		// calculate offsets
1182		horizontalOffset = roffset.exec( pos[ 0 ] );
1183		verticalOffset = roffset.exec( pos[ 1 ] );
1184		offsets[ this ] = [
1185			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1186			verticalOffset ? verticalOffset[ 0 ] : 0
1187		];
1188
1189		// reduce to just the positions without the offsets
1190		options[ this ] = [
1191			rposition.exec( pos[ 0 ] )[ 0 ],
1192			rposition.exec( pos[ 1 ] )[ 0 ]
1193		];
1194	});
1195
1196	// normalize collision option
1197	if ( collision.length === 1 ) {
1198		collision[ 1 ] = collision[ 0 ];
1199	}
1200
1201	if ( options.at[ 0 ] === "right" ) {
1202		basePosition.left += targetWidth;
1203	} else if ( options.at[ 0 ] === "center" ) {
1204		basePosition.left += targetWidth / 2;
1205	}
1206
1207	if ( options.at[ 1 ] === "bottom" ) {
1208		basePosition.top += targetHeight;
1209	} else if ( options.at[ 1 ] === "center" ) {
1210		basePosition.top += targetHeight / 2;
1211	}
1212
1213	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1214	basePosition.left += atOffset[ 0 ];
1215	basePosition.top += atOffset[ 1 ];
1216
1217	return this.each(function() {
1218		var collisionPosition, using,
1219			elem = $( this ),
1220			elemWidth = elem.outerWidth(),
1221			elemHeight = elem.outerHeight(),
1222			marginLeft = parseCss( this, "marginLeft" ),
1223			marginTop = parseCss( this, "marginTop" ),
1224			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1225			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1226			position = $.extend( {}, basePosition ),
1227			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1228
1229		if ( options.my[ 0 ] === "right" ) {
1230			position.left -= elemWidth;
1231		} else if ( options.my[ 0 ] === "center" ) {
1232			position.left -= elemWidth / 2;
1233		}
1234
1235		if ( options.my[ 1 ] === "bottom" ) {
1236			position.top -= elemHeight;
1237		} else if ( options.my[ 1 ] === "center" ) {
1238			position.top -= elemHeight / 2;
1239		}
1240
1241		position.left += myOffset[ 0 ];
1242		position.top += myOffset[ 1 ];
1243
1244		// if the browser doesn't support fractions, then round for consistent results
1245		if ( !supportsOffsetFractions ) {
1246			position.left = round( position.left );
1247			position.top = round( position.top );
1248		}
1249
1250		collisionPosition = {
1251			marginLeft: marginLeft,
1252			marginTop: marginTop
1253		};
1254
1255		$.each( [ "left", "top" ], function( i, dir ) {
1256			if ( $.ui.position[ collision[ i ] ] ) {
1257				$.ui.position[ collision[ i ] ][ dir ]( position, {
1258					targetWidth: targetWidth,
1259					targetHeight: targetHeight,
1260					elemWidth: elemWidth,
1261					elemHeight: elemHeight,
1262					collisionPosition: collisionPosition,
1263					collisionWidth: collisionWidth,
1264					collisionHeight: collisionHeight,
1265					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1266					my: options.my,
1267					at: options.at,
1268					within: within,
1269					elem: elem
1270				});
1271			}
1272		});
1273
1274		if ( options.using ) {
1275			// adds feedback as second argument to using callback, if present
1276			using = function( props ) {
1277				var left = targetOffset.left - position.left,
1278					right = left + targetWidth - elemWidth,
1279					top = targetOffset.top - position.top,
1280					bottom = top + targetHeight - elemHeight,
1281					feedback = {
1282						target: {
1283							element: target,
1284							left: targetOffset.left,
1285							top: targetOffset.top,
1286							width: targetWidth,
1287							height: targetHeight
1288						},
1289						element: {
1290							element: elem,
1291							left: position.left,
1292							top: position.top,
1293							width: elemWidth,
1294							height: elemHeight
1295						},
1296						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1297						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1298					};
1299				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1300					feedback.horizontal = "center";
1301				}
1302				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1303					feedback.vertical = "middle";
1304				}
1305				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1306					feedback.important = "horizontal";
1307				} else {
1308					feedback.important = "vertical";
1309				}
1310				options.using.call( this, props, feedback );
1311			};
1312		}
1313
1314		elem.offset( $.extend( position, { using: using } ) );
1315	});
1316};
1317
1318$.ui.position = {
1319	fit: {
1320		left: function( position, data ) {
1321			var within = data.within,
1322				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1323				outerWidth = within.width,
1324				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1325				overLeft = withinOffset - collisionPosLeft,
1326				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1327				newOverRight;
1328
1329			// element is wider than within
1330			if ( data.collisionWidth > outerWidth ) {
1331				// element is initially over the left side of within
1332				if ( overLeft > 0 && overRight <= 0 ) {
1333					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1334					position.left += overLeft - newOverRight;
1335				// element is initially over right side of within
1336				} else if ( overRight > 0 && overLeft <= 0 ) {
1337					position.left = withinOffset;
1338				// element is initially over both left and right sides of within
1339				} else {
1340					if ( overLeft > overRight ) {
1341						position.left = withinOffset + outerWidth - data.collisionWidth;
1342					} else {
1343						position.left = withinOffset;
1344					}
1345				}
1346			// too far left -> align with left edge
1347			} else if ( overLeft > 0 ) {
1348				position.left += overLeft;
1349			// too far right -> align with right edge
1350			} else if ( overRight > 0 ) {
1351				position.left -= overRight;
1352			// adjust based on position and margin
1353			} else {
1354				position.left = max( position.left - collisionPosLeft, position.left );
1355			}
1356		},
1357		top: function( position, data ) {
1358			var within = data.within,
1359				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1360				outerHeight = data.within.height,
1361				collisionPosTop = position.top - data.collisionPosition.marginTop,
1362				overTop = withinOffset - collisionPosTop,
1363				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1364				newOverBottom;
1365
1366			// element is taller than within
1367			if ( data.collisionHeight > outerHeight ) {
1368				// element is initially over the top of within
1369				if ( overTop > 0 && overBottom <= 0 ) {
1370					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1371					position.top += overTop - newOverBottom;
1372				// element is initially over bottom of within
1373				} else if ( overBottom > 0 && overTop <= 0 ) {
1374					position.top = withinOffset;
1375				// element is initially over both top and bottom of within
1376				} else {
1377					if ( overTop > overBottom ) {
1378						position.top = withinOffset + outerHeight - data.collisionHeight;
1379					} else {
1380						position.top = withinOffset;
1381					}
1382				}
1383			// too far up -> align with top
1384			} else if ( overTop > 0 ) {
1385				position.top += overTop;
1386			// too far down -> align with bottom edge
1387			} else if ( overBottom > 0 ) {
1388				position.top -= overBottom;
1389			// adjust based on position and margin
1390			} else {
1391				position.top = max( position.top - collisionPosTop, position.top );
1392			}
1393		}
1394	},
1395	flip: {
1396		left: function( position, data ) {
1397			var within = data.within,
1398				withinOffset = within.offset.left + within.scrollLeft,
1399				outerWidth = within.width,
1400				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1401				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1402				overLeft = collisionPosLeft - offsetLeft,
1403				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1404				myOffset = data.my[ 0 ] === "left" ?
1405					-data.elemWidth :
1406					data.my[ 0 ] === "right" ?
1407						data.elemWidth :
1408						0,
1409				atOffset = data.at[ 0 ] === "left" ?
1410					data.targetWidth :
1411					data.at[ 0 ] === "right" ?
1412						-data.targetWidth :
1413						0,
1414				offset = -2 * data.offset[ 0 ],
1415				newOverRight,
1416				newOverLeft;
1417
1418			if ( overLeft < 0 ) {
1419				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1420				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1421					position.left += myOffset + atOffset + offset;
1422				}
1423			} else if ( overRight > 0 ) {
1424				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1425				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1426					position.left += myOffset + atOffset + offset;
1427				}
1428			}
1429		},
1430		top: function( position, data ) {
1431			var within = data.within,
1432				withinOffset = within.offset.top + within.scrollTop,
1433				outerHeight = within.height,
1434				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1435				collisionPosTop = position.top - data.collisionPosition.marginTop,
1436				overTop = collisionPosTop - offsetTop,
1437				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1438				top = data.my[ 1 ] === "top",
1439				myOffset = top ?
1440					-data.elemHeight :
1441					data.my[ 1 ] === "bottom" ?
1442						data.elemHeight :
1443						0,
1444				atOffset = data.at[ 1 ] === "top" ?
1445					data.targetHeight :
1446					data.at[ 1 ] === "bottom" ?
1447						-data.targetHeight :
1448						0,
1449				offset = -2 * data.offset[ 1 ],
1450				newOverTop,
1451				newOverBottom;
1452			if ( overTop < 0 ) {
1453				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1454				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1455					position.top += myOffset + atOffset + offset;
1456				}
1457			} else if ( overBottom > 0 ) {
1458				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1459				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1460					position.top += myOffset + atOffset + offset;
1461				}
1462			}
1463		}
1464	},
1465	flipfit: {
1466		left: function() {
1467			$.ui.position.flip.left.apply( this, arguments );
1468			$.ui.position.fit.left.apply( this, arguments );
1469		},
1470		top: function() {
1471			$.ui.position.flip.top.apply( this, arguments );
1472			$.ui.position.fit.top.apply( this, arguments );
1473		}
1474	}
1475};
1476
1477// fraction support test
1478(function() {
1479	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1480		body = document.getElementsByTagName( "body" )[ 0 ],
1481		div = document.createElement( "div" );
1482
1483	//Create a "fake body" for testing based on method used in jQuery.support
1484	testElement = document.createElement( body ? "div" : "body" );
1485	testElementStyle = {
1486		visibility: "hidden",
1487		width: 0,
1488		height: 0,
1489		border: 0,
1490		margin: 0,
1491		background: "none"
1492	};
1493	if ( body ) {
1494		$.extend( testElementStyle, {
1495			position: "absolute",
1496			left: "-1000px",
1497			top: "-1000px"
1498		});
1499	}
1500	for ( i in testElementStyle ) {
1501		testElement.style[ i ] = testElementStyle[ i ];
1502	}
1503	testElement.appendChild( div );
1504	testElementParent = body || document.documentElement;
1505	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1506
1507	div.style.cssText = "position: absolute; left: 10.7432222px;";
1508
1509	offsetLeft = $( div ).offset().left;
1510	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1511
1512	testElement.innerHTML = "";
1513	testElementParent.removeChild( testElement );
1514})();
1515
1516})();
1517
1518var position = $.ui.position;
1519
1520
1521/*!
1522 * jQuery UI Accordion 1.11.

1534",
1535	options: {
1536		active: 0,
1537		animate: {},
1538		collapsible: false,
1539		event: "click",
1540		header: "> li > :first-child,> :not(li):even",
1541		heightStyle: "auto",
1542		icons: {
1543			activeHeader: "ui-icon-triangle-1-s",
1544			header: "ui-icon-triangle-1-e"
1545		},
1546
1547		// callbacks
1548		activate: null,
1549		beforeActivate: null
1550	},
1551
1552	hideProps: {
1553		borderTopWidth: "hide",
1554		borderBottomWidth: "hide",
1555		paddingTop: "hide",
1556		paddingBottom: "hide",
1557		height: "hide"
1558	},
1559
1560	showProps: {
1561		borderTopWidth: "show",
1562		borderBottomWidth: "show",
1563		paddingTop: "show",
1564		paddingBottom: "show",
1565		height: "show"
1566	},
1567
1568	_create: function() {
1569		var options = this.options;
1570		this.prevShow = this.prevHide = $();
1571		this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1572			// ARIA
1573			.attr( "role", "tablist" );
1574
1575		// don't allow collapsible: false and active: false / null
1576		if ( !options.collapsible && (options.active === false || options.active == null) ) {
1577			options.active = 0;
1578		}
1579
1580		this._processPanels();
1581		// handle negative values
1582		if ( options.active < 0 ) {
1583			options.active += this.headers.length;
1584		}
1585		this._refresh();
1586	},
1587
1588	_getCreateEventData: function() {
1589		return {
1590			header: this.active,
1591			panel: !this.active.length ? $() : this.active.next()
1592		};
1593	},
1594
1595	_createIcons: function() {
1596		var icons = this.options.icons;
1597		if ( icons ) {
1598			$( "<span>" )
1599				.addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1600				.prependTo( this.headers );
1601			this.active.children( ".ui-accordion-header-icon" )
1602				.removeClass( icons.header )
1603				.addClass( icons.activeHeader );
1604			this.headers.addClass( "ui-accordion-icons" );
1605		}
1606	},
1607
1608	_destroyIcons: function() {
1609		this.headers
1610			.removeClass( "ui-accordion-icons" )
1611			.children( ".ui-accordion-header-icon" )
1612				.remove();
1613	},
1614
1615	_destroy: function() {
1616		var contents;
1617
1618		// clean up main element
1619		this.element
1620			.removeClass( "ui-accordion ui-widget ui-helper-reset" )
1621			.removeAttr( "role" );
1622
1623		// clean up headers
1624		this.headers
1625			.removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1626				"ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1627			.removeAttr( "role" )
1628			.removeAttr( "aria-expanded" )
1629			.removeAttr( "aria-selected" )
1630			.removeAttr( "aria-controls" )
1631			.removeAttr( "tabIndex" )
1632			.removeUniqueId();
1633
1634		this._destroyIcons();
1635
1636		// clean up content panels
1637		contents = this.headers.next()
1638			.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1639				"ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1640			.css( "display", "" )
1641			.removeAttr( "role" )
1642			.removeAttr( "aria-hidden" )
1643			.removeAttr( "aria-labelledby" )
1644			.removeUniqueId();
1645
1646		if ( this.options.heightStyle !== "content" ) {
1647			contents.css( "height", "" );
1648		}
1649	},
1650
1651	_setOption: function( key, value ) {
1652		if ( key === "active" ) {
1653			// _activate() will handle invalid values and update this.options
1654			this._activate( value );
1655			return;
1656		}
1657
1658		if ( key === "event" ) {
1659			if ( this.options.event ) {
1660				this._off( this.headers, this.options.event );
1661			}
1662			this._setupEvents( value );
1663		}
1664
1665		this._super( key, value );
1666
1667		// setting collapsible: false while collapsed; open first panel
1668		if ( key === "collapsible" && !value && this.options.active === false ) {
1669			this._activate( 0 );
1670		}
1671
1672		if ( key === "icons" ) {
1673			this._destroyIcons();
1674			if ( value ) {
1675				this._createIcons();
1676			}
1677		}
1678
1679		// #5332 - opacity doesn't cascade to positioned elements in IE
1680		// so we need to add the disabled class to the headers and panels
1681		if ( key === "disabled" ) {
1682			this.element
1683				.toggleClass( "ui-state-disabled", !!value )
1684				.attr( "aria-disabled", value );
1685			this.headers.add( this.headers.next() )
1686				.toggleClass( "ui-state-disabled", !!value );
1687		}
1688	},
1689
1690	_keydown: function( event ) {
1691		if ( event.altKey || event.ctrlKey ) {
1692			return;
1693		}
1694
1695		var keyCode = $.ui.keyCode,
1696			length = this.headers.length,
1697			currentIndex = this.headers.index( event.target ),
1698			toFocus = false;
1699
1700		switch ( event.keyCode ) {
1701			case keyCode.RIGHT:
1702			case keyCode.DOWN:
1703				toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1704				break;
1705			case keyCode.LEFT:
1706			case keyCode.UP:
1707				toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1708				break;
1709			case keyCode.SPACE:
1710			case keyCode.ENTER:
1711				this._eventHandler( event );
1712				break;
1713			case keyCode.HOME:
1714				toFocus = this.headers[ 0 ];
1715				break;
1716			case keyCode.END:
1717				toFocus = this.headers[ length - 1 ];
1718				break;
1719		}
1720
1721		if ( toFocus ) {
1722			$( event.target ).attr( "tabIndex", -1 );
1723			$( toFocus ).attr( "tabIndex", 0 );
1724			toFocus.focus();
1725			event.preventDefault();
1726		}
1727	},
1728
1729	_panelKeyDown: function( event ) {
1730		if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1731			$( event.currentTarget ).prev().focus();
1732		}
1733	},
1734
1735	refresh: function() {
1736		var options = this.options;
1737		this._processPanels();
1738
1739		// was collapsed or no panel
1740		if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1741			options.active = false;
1742			this.active = $();
1743		// active false only when collapsible is true
1744		} else if ( options.active === false ) {
1745			this._activate( 0 );
1746		// was active, but active panel is gone
1747		} else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1748			// all remaining panel are disabled
1749			if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1750				options.active = false;
1751				this.active = $();
1752			// activate previous panel
1753			} else {
1754				this._activate( Math.max( 0, options.active - 1 ) );
1755			}
1756		// was active, active panel still exists
1757		} else {
1758			// make sure active index is correct
1759			options.active = this.headers.index( this.active );
1760		}
1761
1762		this._destroyIcons();
1763
1764		this._refresh();
1765	},
1766
1767	_processPanels: function() {
1768		this.headers = this.element.find( this.options.header )
1769			.addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1770
1771		this.headers.next()
1772			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1773			.filter( ":not(.ui-accordion-content-active)" )
1774			.hide();
1775	},
1776
1777	_refresh: function() {
1778		var maxHeight,
1779			options = this.options,
1780			heightStyle = options.heightStyle,
1781			parent = this.element.parent();
1782
1783		this.active = this._findActive( options.active )
1784			.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1785			.removeClass( "ui-corner-all" );
1786		this.active.next()
1787			.addClass( "ui-accordion-content-active" )
1788			.show();
1789
1790		this.headers
1791			.attr( "role", "tab" )
1792			.each(function() {
1793				var header = $( this ),
1794					headerId = header.uniqueId().attr( "id" ),
1795					panel = header.next(),
1796					panelId = panel.uniqueId().attr( "id" );
1797				header.attr( "aria-controls", panelId );
1798				panel.attr( "aria-labelledby", headerId );
1799			})
1800			.next()
1801				.attr( "role", "tabpanel" );
1802
1803		this.headers
1804			.not( this.active )
1805			.attr({
1806				"aria-selected": "false",
1807				"aria-expanded": "false",
1808				tabIndex: -1
1809			})
1810			.next()
1811				.attr({
1812					"aria-hidden": "true"
1813				})
1814				.hide();
1815
1816		// make sure at least one header is in the tab order
1817		if ( !this.active.length ) {
1818			this.headers.eq( 0 ).attr( "tabIndex", 0 );
1819		} else {
1820			this.active.attr({
1821				"aria-selected": "true",
1822				"aria-expanded": "true",
1823				tabIndex: 0
1824			})
1825			.next()
1826				.attr({
1827					"aria-hidden": "false"
1828				});
1829		}
1830
1831		this._createIcons();
1832
1833		this._setupEvents( options.event );
1834
1835		if ( heightStyle === "fill" ) {
1836			maxHeight = parent.height();
1837			this.element.siblings( ":visible" ).each(function() {
1838				var elem = $( this ),
1839					position = elem.css( "position" );
1840
1841				if ( position === "absolute" || position === "fixed" ) {
1842					return;
1843				}
1844				maxHeight -= elem.outerHeight( true );
1845			});
1846
1847			this.headers.each(function() {
1848				maxHeight -= $( this ).outerHeight( true );
1849			});
1850
1851			this.headers.next()
1852				.each(function() {
1853					$( this ).height( Math.max( 0, maxHeight -
1854						$( this ).innerHeight() + $( this ).height() ) );
1855				})
1856				.css( "overflow", "auto" );
1857		} else if ( heightStyle === "auto" ) {
1858			maxHeight = 0;
1859			this.headers.next()
1860				.each(function() {
1861					maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1862				})
1863				.height( maxHeight );
1864		}
1865	},
1866
1867	_activate: function( index ) {
1868		var active = this._findActive( index )[ 0 ];
1869
1870		// trying to activate the already active panel
1871		if ( active === this.active[ 0 ] ) {
1872			return;
1873		}
1874
1875		// trying to collapse, simulate a click on the currently active header
1876		active = active || this.active[ 0 ];
1877
1878		this._eventHandler({
1879			target: active,
1880			currentTarget: active,
1881			preventDefault: $.noop
1882		});
1883	},
1884
1885	_findActive: function( selector ) {
1886		return typeof selector === "number" ? this.headers.eq( selector ) : $();
1887	},
1888
1889	_setupEvents: function( event ) {
1890		var events = {
1891			keydown: "_keydown"
1892		};
1893		if ( event ) {
1894			$.each( event.split( " " ), function( index, eventName ) {
1895				events[ eventName ] = "_eventHandler";
1896			});
1897		}
1898
1899		this._off( this.headers.add( this.headers.next() ) );
1900		this._on( this.headers, events );
1901		this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1902		this._hoverable( this.headers );
1903		this._focusable( this.headers );
1904	},
1905
1906	_eventHandler: function( event ) {
1907		var options = this.options,
1908			active = this.active,
1909			clicked = $( event.currentTarget ),
1910			clickedIsActive = clicked[ 0 ] === active[ 0 ],
1911			collapsing = clickedIsActive && options.collapsible,
1912			toShow = collapsing ? $() : clicked.next(),
1913			toHide = active.next(),
1914			eventData = {
1915				oldHeader: active,
1916				oldPanel: toHide,
1917				newHeader: collapsing ? $() : clicked,
1918				newPanel: toShow
1919			};
1920
1921		event.preventDefault();
1922
1923		if (
1924				// click on active header, but not collapsible
1925				( clickedIsActive && !options.collapsible ) ||
1926				// allow canceling activation
1927				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1928			return;
1929		}
1930
1931		options.active = collapsing ? false : this.headers.index( clicked );
1932
1933		// when the call to ._toggle() comes after the class changes
1934		// it causes a very odd bug in IE 8 (see #6720)
1935		this.active = clickedIsActive ? $() : clicked;
1936		this._toggle( eventData );
1937
1938		// switch classes
1939		// corner classes on the previously active header stay after the animation
1940		active.removeClass( "ui-accordion-header-active ui-state-active" );
1941		if ( options.icons ) {
1942			active.children( ".ui-accordion-header-icon" )
1943				.removeClass( options.icons.activeHeader )
1944				.addClass( options.icons.header );
1945		}
1946
1947		if ( !clickedIsActive ) {
1948			clicked
1949				.removeClass( "ui-corner-all" )
1950				.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1951			if ( options.icons ) {
1952				clicked.children( ".ui-accordion-header-icon" )
1953					.removeClass( options.icons.header )
1954					.addClass( options.icons.activeHeader );
1955			}
1956
1957			clicked
1958				.next()
1959				.addClass( "ui-accordion-content-active" );
1960		}
1961	},
1962
1963	_toggle: function( data ) {
1964		var toShow = data.newPanel,
1965			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
1966
1967		// handle activating a panel during the animation for another activation
1968		this.prevShow.add( this.prevHide ).stop( true, true );
1969		this.prevShow = toShow;
1970		this.prevHide = toHide;
1971
1972		if ( this.options.animate ) {
1973			this._animate( toShow, toHide, data );
1974		} else {
1975			toHide.hide();
1976			toShow.show();
1977			this._toggleComplete( data );
1978		}
1979
1980		toHide.attr({
1981			"aria-hidden": "true"
1982		});
1983		toHide.prev().attr( "aria-selected", "false" );
1984		// if we're switching panels, remove the old header from the tab order
1985		// if we're opening from collapsed state, remove the previous header from the tab order
1986		// if we're collapsing, then keep the collapsing header in the tab order
1987		if ( toShow.length && toHide.length ) {
1988			toHide.prev().attr({
1989				"tabIndex": -1,
1990				"aria-expanded": "false"
1991			});
1992		} else if ( toShow.length ) {
1993			this.headers.filter(function() {
1994				return $( this ).attr( "tabIndex" ) === 0;
1995			})
1996			.attr( "tabIndex", -1 );
1997		}
1998
1999		toShow
2000			.attr( "aria-hidden", "false" )
2001			.prev()
2002				.attr({
2003					"aria-selected": "true",
2004					tabIndex: 0,
2005					"aria-expanded": "true"
2006				});
2007	},
2008
2009	_animate: function( toShow, toHide, data ) {
2010		var total, easing, duration,
2011			that = this,
2012			adjust = 0,
2013			down = toShow.length &&
2014				( !toHide.length || ( toShow.index() < toHide.index() ) ),
2015			animate = this.options.animate || {},
2016			options = down && animate.down || animate,
2017			complete = function() {
2018				that._toggleComplete( data );
2019			};
2020
2021		if ( typeof options === "number" ) {
2022			duration = options;
2023		}
2024		if ( typeof options === "string" ) {
2025			easing = options;
2026		}
2027		// fall back from options to animation in case of partial down settings
2028		easing = easing || options.easing || animate.easing;
2029		duration = duration || options.duration || animate.duration;
2030
2031		if ( !toHide.length ) {
2032			return toShow.animate( this.showProps, duration, easing, complete );
2033		}
2034		if ( !toShow.length ) {
2035			return toHide.animate( this.hideProps, duration, easing, complete );
2036		}
2037
2038		total = toShow.show().outerHeight();
2039		toHide.animate( this.hideProps, {
2040			duration: duration,
2041			easing: easing,
2042			step: function( now, fx ) {
2043				fx.now = Math.round( now );
2044			}
2045		});
2046		toShow
2047			.hide()
2048			.animate( this.showProps, {
2049				duration: duration,
2050				easing: easing,
2051				complete: complete,
2052				step: function( now, fx ) {
2053					fx.now = Math.round( now );
2054					if ( fx.prop !== "height" ) {
2055						adjust += fx.now;
2056					} else if ( that.options.heightStyle !== "content" ) {
2057						fx.now = Math.round( total - toHide.outerHeight() - adjust );
2058						adjust = 0;
2059					}
2060				}
2061			});
2062	},
2063
2064	_toggleComplete: function( data ) {
2065		var toHide = data.oldPanel;
2066
2067		toHide
2068			.removeClass( "ui-accordion-content-active" )
2069			.prev()
2070				.removeClass( "ui-corner-top" )
2071				.addClass( "ui-corner-all" );
2072
2073		// Work around for rendering bug in IE (#5421)
2074		if ( toHide.length ) {
2075			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2076		}
2077		this._trigger( "activate", null, data );
2078	}
2079});
2080
2081
2082/*!
2083 * jQuery UI Menu 1.11.

2095",
2096	defaultElement: "<ul>",
2097	delay: 300,
2098	options: {
2099		icons: {
2100			submenu: "ui-icon-carat-1-e"
2101		},
2102		items: "> *",
2103		menus: "ul",
2104		position: {
2105			my: "left-1 top",
2106			at: "right top"
2107		},
2108		role: "menu",
2109
2110		// callbacks
2111		blur: null,
2112		focus: null,
2113		select: null
2114	},
2115
2116	_create: function() {
2117		this.activeMenu = this.element;
2118
2119		// Flag used to prevent firing of the click handler
2120		// as the event bubbles up through nested menus
2121		this.mouseHandled = false;
2122		this.element
2123			.uniqueId()
2124			.addClass( "ui-menu ui-widget ui-widget-content" )
2125			.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2126			.attr({
2127				role: this.options.role,
2128				tabIndex: 0
2129			});
2130
2131		if ( this.options.disabled ) {
2132			this.element
2133				.addClass( "ui-state-disabled" )
2134				.attr( "aria-disabled", "true" );
2135		}
2136
2137		this._on({
2138			// Prevent focus from sticking to links inside menu after clicking
2139			// them (focus should always stay on UL during navigation).
2140			"mousedown .ui-menu-item": function( event ) {
2141				event.preventDefault();
2142			},
2143			"click .ui-menu-item": function( event ) {
2144				var target = $( event.target );
2145				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2146					this.select( event );
2147
2148					// Only set the mouseHandled flag if the event will bubble, see #9469.
2149					if ( !event.isPropagationStopped() ) {
2150						this.mouseHandled = true;
2151					}
2152
2153					// Open submenu on click
2154					if ( target.has( ".ui-menu" ).length ) {
2155						this.expand( event );
2156					} else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2157
2158						// Redirect focus to the menu
2159						this.element.trigger( "focus", [ true ] );
2160
2161						// If the active item is on the top level, let it stay active.
2162						// Otherwise, blur the active item since it is no longer visible.
2163						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2164							clearTimeout( this.timer );
2165						}
2166					}
2167				}
2168			},
2169			"mouseenter .ui-menu-item": function( event ) {
2170				var target = $( event.currentTarget );
2171				// Remove ui-state-active class from siblings of the newly focused menu item
2172				// to avoid a jump caused by adjacent elements both having a class with a border
2173				target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2174				this.focus( event, target );
2175			},
2176			mouseleave: "collapseAll",
2177			"mouseleave .ui-menu": "collapseAll",
2178			focus: function( event, keepActiveItem ) {
2179				// If there's already an active item, keep it active
2180				// If not, activate the first item
2181				var item = this.active || this.element.find( this.options.items ).eq( 0 );
2182
2183				if ( !keepActiveItem ) {
2184					this.focus( event, item );
2185				}
2186			},
2187			blur: function( event ) {
2188				this._delay(function() {
2189					if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2190						this.collapseAll( event );
2191					}
2192				});
2193			},
2194			keydown: "_keydown"
2195		});
2196
2197		this.refresh();
2198
2199		// Clicks outside of a menu collapse any open menus
2200		this._on( this.document, {
2201			click: function( event ) {
2202				if ( this._closeOnDocumentClick( event ) ) {
2203					this.collapseAll( event );
2204				}
2205
2206				// Reset the mouseHandled flag
2207				this.mouseHandled = false;
2208			}
2209		});
2210	},
2211
2212	_destroy: function() {
2213		// Destroy (sub)menus
2214		this.element
2215			.removeAttr( "aria-activedescendant" )
2216			.find( ".ui-menu" ).addBack()
2217				.removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2218				.removeAttr( "role" )
2219				.removeAttr( "tabIndex" )
2220				.removeAttr( "aria-labelledby" )
2221				.removeAttr( "aria-expanded" )
2222				.removeAttr( "aria-hidden" )
2223				.removeAttr( "aria-disabled" )
2224				.removeUniqueId()
2225				.show();
2226
2227		// Destroy menu items
2228		this.element.find( ".ui-menu-item" )
2229			.removeClass( "ui-menu-item" )
2230			.removeAttr( "role" )
2231			.removeAttr( "aria-disabled" )
2232			.removeUniqueId()
2233			.removeClass( "ui-state-hover" )
2234			.removeAttr( "tabIndex" )
2235			.removeAttr( "role" )
2236			.removeAttr( "aria-haspopup" )
2237			.children().each( function() {
2238				var elem = $( this );
2239				if ( elem.data( "ui-menu-submenu-carat" ) ) {
2240					elem.remove();
2241				}
2242			});
2243
2244		// Destroy menu dividers
2245		this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2246	},
2247
2248	_keydown: function( event ) {
2249		var match, prev, character, skip, regex,
2250			preventDefault = true;
2251
2252		function escape( value ) {
2253			return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
2254		}
2255
2256		switch ( event.keyCode ) {
2257		case $.ui.keyCode.PAGE_UP:
2258			this.previousPage( event );
2259			break;
2260		case $.ui.keyCode.PAGE_DOWN:
2261			this.nextPage( event );
2262			break;
2263		case $.ui.keyCode.HOME:
2264			this._move( "first", "first", event );
2265			break;
2266		case $.ui.keyCode.END:
2267			this._move( "last", "last", event );
2268			break;
2269		case $.ui.keyCode.UP:
2270			this.previous( event );
2271			break;
2272		case $.ui.keyCode.DOWN:
2273			this.next( event );
2274			break;
2275		case $.ui.keyCode.LEFT:
2276			this.collapse( event );
2277			break;
2278		case $.ui.keyCode.RIGHT:
2279			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2280				this.expand( event );
2281			}
2282			break;
2283		case $.ui.keyCode.ENTER:
2284		case $.ui.keyCode.SPACE:
2285			this._activate( event );
2286			break;
2287		case $.ui.keyCode.ESCAPE:
2288			this.collapse( event );
2289			break;
2290		default:
2291			preventDefault = false;
2292			prev = this.previousFilter || "";
2293			character = String.fromCharCode( event.keyCode );
2294			skip = false;
2295
2296			clearTimeout( this.filterTimer );
2297
2298			if ( character === prev ) {
2299				skip = true;
2300			} else {
2301				character = prev + character;
2302			}
2303
2304			regex = new RegExp( "^" + escape( character ), "i" );
2305			match = this.activeMenu.find( this.options.items ).filter(function() {
2306				return regex.test( $( this ).text() );
2307			});
2308			match = skip && match.index( this.active.next() ) !== -1 ?
2309				this.active.nextAll( ".ui-menu-item" ) :
2310				match;
2311
2312			// If no matches on the current filter, reset to the last character pressed
2313			// to move down the menu to the first item that starts with that character
2314			if ( !match.length ) {
2315				character = String.fromCharCode( event.keyCode );
2316				regex = new RegExp( "^" + escape( character ), "i" );
2317				match = this.activeMenu.find( this.options.items ).filter(function() {
2318					return regex.test( $( this ).text() );
2319				});
2320			}
2321
2322			if ( match.length ) {
2323				this.focus( event, match );
2324				if ( match.length > 1 ) {
2325					this.previousFilter = character;
2326					this.filterTimer = this._delay(function() {
2327						delete this.previousFilter;
2328					}, 1000 );
2329				} else {
2330					delete this.previousFilter;
2331				}
2332			} else {
2333				delete this.previousFilter;
2334			}
2335		}
2336
2337		if ( preventDefault ) {
2338			event.preventDefault();
2339		}
2340	},
2341
2342	_activate: function( event ) {
2343		if ( !this.active.is( ".ui-state-disabled" ) ) {
2344			if ( this.active.is( "[aria-haspopup='true']" ) ) {
2345				this.expand( event );
2346			} else {
2347				this.select( event );
2348			}
2349		}
2350	},
2351
2352	refresh: function() {
2353		var menus, items,
2354			that = this,
2355			icon = this.options.icons.submenu,
2356			submenus = this.element.find( this.options.menus );
2357
2358		this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2359
2360		// Initialize nested menus
2361		submenus.filter( ":not(.ui-menu)" )
2362			.addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2363			.hide()
2364			.attr({
2365				role: this.options.role,
2366				"aria-hidden": "true",
2367				"aria-expanded": "false"
2368			})
2369			.each(function() {
2370				var menu = $( this ),
2371					item = menu.parent(),
2372					submenuCarat = $( "<span>" )
2373						.addClass( "ui-menu-icon ui-icon " + icon )
2374						.data( "ui-menu-submenu-carat", true );
2375
2376				item
2377					.attr( "aria-haspopup", "true" )
2378					.prepend( submenuCarat );
2379				menu.attr( "aria-labelledby", item.attr( "id" ) );
2380			});
2381
2382		menus = submenus.add( this.element );
2383		items = menus.find( this.options.items );
2384
2385		// Initialize menu-items containing spaces and/or dashes only as dividers
2386		items.not( ".ui-menu-item" ).each(function() {
2387			var item = $( this );
2388			if ( that._isDivider( item ) ) {
2389				item.addClass( "ui-widget-content ui-menu-divider" );
2390			}
2391		});
2392
2393		// Don't refresh list items that are already adapted
2394		items.not( ".ui-menu-item, .ui-menu-divider" )
2395			.addClass( "ui-menu-item" )
2396			.uniqueId()
2397			.attr({
2398				tabIndex: -1,
2399				role: this._itemRole()
2400			});
2401
2402		// Add aria-disabled attribute to any disabled menu item
2403		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2404
2405		// If the active item has been removed, blur the menu
2406		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2407			this.blur();
2408		}
2409	},
2410
2411	_itemRole: function() {
2412		return {
2413			menu: "menuitem",
2414			listbox: "option"
2415		}[ this.options.role ];
2416	},
2417
2418	_setOption: function( key, value ) {
2419		if ( key === "icons" ) {
2420			this.element.find( ".ui-menu-icon" )
2421				.removeClass( this.options.icons.submenu )
2422				.addClass( value.submenu );
2423		}
2424		if ( key === "disabled" ) {
2425			this.element
2426				.toggleClass( "ui-state-disabled", !!value )
2427				.attr( "aria-disabled", value );
2428		}
2429		this._super( key, value );
2430	},
2431
2432	focus: function( event, item ) {
2433		var nested, focused;
2434		this.blur( event, event && event.type === "focus" );
2435
2436		this._scrollIntoView( item );
2437
2438		this.active = item.first();
2439		focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2440		// Only update aria-activedescendant if there's a role
2441		// otherwise we assume focus is managed elsewhere
2442		if ( this.options.role ) {
2443			this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2444		}
2445
2446		// Highlight active parent menu item, if any
2447		this.active
2448			.parent()
2449			.closest( ".ui-menu-item" )
2450			.addClass( "ui-state-active" );
2451
2452		if ( event && event.type === "keydown" ) {
2453			this._close();
2454		} else {
2455			this.timer = this._delay(function() {
2456				this._close();
2457			}, this.delay );
2458		}
2459
2460		nested = item.children( ".ui-menu" );
2461		if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2462			this._startOpening(nested);
2463		}
2464		this.activeMenu = item.parent();
2465
2466		this._trigger( "focus", event, { item: item } );
2467	},
2468
2469	_scrollIntoView: function( item ) {
2470		var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2471		if ( this._hasScroll() ) {
2472			borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2473			paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2474			offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2475			scroll = this.activeMenu.scrollTop();
2476			elementHeight = this.activeMenu.height();
2477			itemHeight = item.outerHeight();
2478
2479			if ( offset < 0 ) {
2480				this.activeMenu.scrollTop( scroll + offset );
2481			} else if ( offset + itemHeight > elementHeight ) {
2482				this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2483			}
2484		}
2485	},
2486
2487	blur: function( event, fromFocus ) {
2488		if ( !fromFocus ) {
2489			clearTimeout( this.timer );
2490		}
2491
2492		if ( !this.active ) {
2493			return;
2494		}
2495
2496		this.active.removeClass( "ui-state-focus" );
2497		this.active = null;
2498
2499		this._trigger( "blur", event, { item: this.active } );
2500	},
2501
2502	_startOpening: function( submenu ) {
2503		clearTimeout( this.timer );
2504
2505		// Don't open if already open fixes a Firefox bug that caused a .5 pixel
2506		// shift in the submenu position when mousing over the carat icon
2507		if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2508			return;
2509		}
2510
2511		this.timer = this._delay(function() {
2512			this._close();
2513			this._open( submenu );
2514		}, this.delay );
2515	},
2516
2517	_open: function( submenu ) {
2518		var position = $.extend({
2519			of: this.active
2520		}, this.options.position );
2521
2522		clearTimeout( this.timer );
2523		this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2524			.hide()
2525			.attr( "aria-hidden", "true" );
2526
2527		submenu
2528			.show()
2529			.removeAttr( "aria-hidden" )
2530			.attr( "aria-expanded", "true" )
2531			.position( position );
2532	},
2533
2534	collapseAll: function( event, all ) {
2535		clearTimeout( this.timer );
2536		this.timer = this._delay(function() {
2537			// If we were passed an event, look for the submenu that contains the event
2538			var currentMenu = all ? this.element :
2539				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2540
2541			// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2542			if ( !currentMenu.length ) {
2543				currentMenu = this.element;
2544			}
2545
2546			this._close( currentMenu );
2547
2548			this.blur( event );
2549			this.activeMenu = currentMenu;
2550		}, this.delay );
2551	},
2552
2553	// With no arguments, closes the currently active menu - if nothing is active
2554	// it closes all menus.  If passed an argument, it will search for menus BELOW
2555	_close: function( startMenu ) {
2556		if ( !startMenu ) {
2557			startMenu = this.active ? this.active.parent() : this.element;
2558		}
2559
2560		startMenu
2561			.find( ".ui-menu" )
2562				.hide()
2563				.attr( "aria-hidden", "true" )
2564				.attr( "aria-expanded", "false" )
2565			.end()
2566			.find( ".ui-state-active" ).not( ".ui-state-focus" )
2567				.removeClass( "ui-state-active" );
2568	},
2569
2570	_closeOnDocumentClick: function( event ) {
2571		return !$( event.target ).closest( ".ui-menu" ).length;
2572	},
2573
2574	_isDivider: function( item ) {
2575
2576		// Match hyphen, em dash, en dash
2577		return !/[^\-\u2014\u2013\s]/.test( item.text() );
2578	},
2579
2580	collapse: function( event ) {
2581		var newItem = this.active &&
2582			this.active.parent().closest( ".ui-menu-item", this.element );
2583		if ( newItem && newItem.length ) {
2584			this._close();
2585			this.focus( event, newItem );
2586		}
2587	},
2588
2589	expand: function( event ) {
2590		var newItem = this.active &&
2591			this.active
2592				.children( ".ui-menu " )
2593				.find( this.options.items )
2594				.first();
2595
2596		if ( newItem && newItem.length ) {
2597			this._open( newItem.parent() );
2598
2599			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2600			this._delay(function() {
2601				this.focus( event, newItem );
2602			});
2603		}
2604	},
2605
2606	next: function( event ) {
2607		this._move( "next", "first", event );
2608	},
2609
2610	previous: function( event ) {
2611		this._move( "prev", "last", event );
2612	},
2613
2614	isFirstItem: function() {
2615		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2616	},
2617
2618	isLastItem: function() {
2619		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2620	},
2621
2622	_move: function( direction, filter, event ) {
2623		var next;
2624		if ( this.active ) {
2625			if ( direction === "first" || direction === "last" ) {
2626				next = this.active
2627					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2628					.eq( -1 );
2629			} else {
2630				next = this.active
2631					[ direction + "All" ]( ".ui-menu-item" )
2632					.eq( 0 );
2633			}
2634		}
2635		if ( !next || !next.length || !this.active ) {
2636			next = this.activeMenu.find( this.options.items )[ filter ]();
2637		}
2638
2639		this.focus( event, next );
2640	},
2641
2642	nextPage: function( event ) {
2643		var item, base, height;
2644
2645		if ( !this.active ) {
2646			this.next( event );
2647			return;
2648		}
2649		if ( this.isLastItem() ) {
2650			return;
2651		}
2652		if ( this._hasScroll() ) {
2653			base = this.active.offset().top;
2654			height = this.element.height();
2655			this.active.nextAll( ".ui-menu-item" ).each(function() {
2656				item = $( this );
2657				return item.offset().top - base - height < 0;
2658			});
2659
2660			this.focus( event, item );
2661		} else {
2662			this.focus( event, this.activeMenu.find( this.options.items )
2663				[ !this.active ? "first" : "last" ]() );
2664		}
2665	},
2666
2667	previousPage: function( event ) {
2668		var item, base, height;
2669		if ( !this.active ) {
2670			this.next( event );
2671			return;
2672		}
2673		if ( this.isFirstItem() ) {
2674			return;
2675		}
2676		if ( this._hasScroll() ) {
2677			base = this.active.offset().top;
2678			height = this.element.height();
2679			this.active.prevAll( ".ui-menu-item" ).each(function() {
2680				item = $( this );
2681				return item.offset().top - base + height > 0;
2682			});
2683
2684			this.focus( event, item );
2685		} else {
2686			this.focus( event, this.activeMenu.find( this.options.items ).first() );
2687		}
2688	},
2689
2690	_hasScroll: function() {
2691		return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2692	},
2693
2694	select: function( event ) {
2695		// TODO: It should never be possible to not have an active item at this
2696		// point, but the tests don't trigger mouseenter before click.
2697		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2698		var ui = { item: this.active };
2699		if ( !this.active.has( ".ui-menu" ).length ) {
2700			this.collapseAll( event, true );
2701		}
2702		this._trigger( "select", event, ui );
2703	}
2704});
2705
2706
2707/*!
2708 * jQuery UI Autocomplete 1.11.