https://www.ciutatrefugi.barcelona/sites/default/files/js/js_f75RCBThpFRiRmQu-gqJVdO-xgiGJylFuxmAdE9h8yU.js

367/*! jQuery UI - v1.11.1 - 2014-08-13
368* http://jqueryui.com
369* 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
370* Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */
371
372(function( factory ) {
373	if ( typeof define === "function" && define.amd ) {
374
375		// AMD. Register as an anonymous module.
376		define([ "jquery" ], factory );
377	} else {
378
379		// Browser globals
380		factory( jQuery );
381	}
382}(function( $ ) {
383/*!
384 * jQuery UI Core 1.11.1
385 * http://jqueryui.com
386 *
387 * Copyright 2014 jQuery Foundation and other contributors
388 * Released under the MIT license.
389 * http://jquery.org/license
390 *
391 * http://api.jqueryui.com/category/ui-core/
392 */
393
394
395// $.ui might exist from components with no dependencies, e.g., $.ui.position
396$.ui = $.ui || {};
397
398$.extend( $.ui, {
399	version: "1.11.1",
400
401	keyCode: {
402		BACKSPACE: 8,
403		COMMA: 188,
404		DELETE: 46,
405		DOWN: 40,
406		END: 35,
407		ENTER: 13,
408		ESCAPE: 27,
409		HOME: 36,
410		LEFT: 37,
411		PAGE_DOWN: 34,
412		PAGE_UP: 33,
413		PERIOD: 190,
414		RIGHT: 39,
415		SPACE: 32,
416		TAB: 9,
417		UP: 38
418	}
419});
420
421// plugins
422$.fn.extend({
423	scrollParent: function( includeHidden ) {
424		var position = this.css( "position" ),
425			excludeStaticParent = position === "absolute",
426			overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
427			scrollParent = this.parents().filter( function() {
428				var parent = $( this );
429				if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
430					return false;
431				}
432				return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
433			}).eq( 0 );
434
435		return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
436	},
437
438	uniqueId: (function() {
439		var uuid = 0;
440
441		return function() {
442			return this.each(function() {
443				if ( !this.id ) {
444					this.id = "ui-id-" + ( ++uuid );
445				}
446			});
447		};
448	})(),
449
450	removeUniqueId: function() {
451		return this.each(function() {
452			if ( /^ui-id-\d+$/.test( this.id ) ) {
453				$( this ).removeAttr( "id" );
454			}
455		});
456	}
457});
458
459// selectors
460function focusable( element, isTabIndexNotNaN ) {
461	var map, mapName, img,
462		nodeName = element.nodeName.toLowerCase();
463	if ( "area" === nodeName ) {
464		map = element.parentNode;
465		mapName = map.name;
466		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
467			return false;
468		}
469		img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
470		return !!img && visible( img );
471	}
472	return ( /input|select|textarea|button|object/.test( nodeName ) ?
473		!element.disabled :
474		"a" === nodeName ?
475			element.href || isTabIndexNotNaN :
476			isTabIndexNotNaN) &&
477		// the element and all of its ancestors must be visible
478		visible( element );
479}
480
481function visible( element ) {
482	return $.expr.filters.visible( element ) &&
483		!$( element ).parents().addBack().filter(function() {
484			return $.css( this, "visibility" ) === "hidden";
485		}).length;
486}
487
488$.extend( $.expr[ ":" ], {
489	data: $.expr.createPseudo ?
490		$.expr.createPseudo(function( dataName ) {
491			return function( elem ) {
492				return !!$.data( elem, dataName );
493			};
494		}) :
495		// support: jQuery <1.8
496		function( elem, i, match ) {
497			return !!$.data( elem, match[ 3 ] );
498		},
499
500	focusable: function( element ) {
501		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
502	},
503
504	tabbable: function( element ) {
505		var tabIndex = $.attr( element, "tabindex" ),
506			isTabIndexNaN = isNaN( tabIndex );
507		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
508	}
509});
510
511// support: jQuery <1.8
512if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
513	$.each( [ "Width", "Height" ], function( i, name ) {
514		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
515			type = name.toLowerCase(),
516			orig = {
517				innerWidth: $.fn.innerWidth,
518				innerHeight: $.fn.innerHeight,
519				outerWidth: $.fn.outerWidth,
520				outerHeight: $.fn.outerHeight
521			};
522
523		function reduce( elem, size, border, margin ) {
524			$.each( side, function() {
525				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
526				if ( border ) {
527					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
528				}
529				if ( margin ) {
530					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
531				}
532			});
533			return size;
534		}
535
536		$.fn[ "inner" + name ] = function( size ) {
537			if ( size === undefined ) {
538				return orig[ "inner" + name ].call( this );
539			}
540
541			return this.each(function() {
542				$( this ).css( type, reduce( this, size ) + "px" );
543			});
544		};
545
546		$.fn[ "outer" + name] = function( size, margin ) {
547			if ( typeof size !== "number" ) {
548				return orig[ "outer" + name ].call( this, size );
549			}
550
551			return this.each(function() {
552				$( this).css( type, reduce( this, size, true, margin ) + "px" );
553			});
554		};
555	});
556}
557
558// support: jQuery <1.8
559if ( !$.fn.addBack ) {
560	$.fn.addBack = function( selector ) {
561		return this.add( selector == null ?
562			this.prevObject : this.prevObject.filter( selector )
563		);
564	};
565}
566
567// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
568if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
569	$.fn.removeData = (function( removeData ) {
570		return function( key ) {
571			if ( arguments.length ) {
572				return removeData.call( this, $.camelCase( key ) );
573			} else {
574				return removeData.call( this );
575			}
576		};
577	})( $.fn.removeData );
578}
579
580// deprecated
581$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
582
583$.fn.extend({
584	focus: (function( orig ) {
585		return function( delay, fn ) {
586			return typeof delay === "number" ?
587				this.each(function() {
588					var elem = this;
589					setTimeout(function() {
590						$( elem ).focus();
591						if ( fn ) {
592							fn.call( elem );
593						}
594					}, delay );
595				}) :
596				orig.apply( this, arguments );
597		};
598	})( $.fn.focus ),
599
600	disableSelection: (function() {
601		var eventType = "onselectstart" in document.createElement( "div" ) ?
602			"selectstart" :
603			"mousedown";
604
605		return function() {
606			return this.bind( eventType + ".ui-disableSelection", function( event ) {
607				event.preventDefault();
608			});
609		};
610	})(),
611
612	enableSelection: function() {
613		return this.unbind( ".ui-disableSelection" );
614	},
615
616	zIndex: function( zIndex ) {
617		if ( zIndex !== undefined ) {
618			return this.css( "zIndex", zIndex );
619		}
620
621		if ( this.length ) {
622			var elem = $( this[ 0 ] ), position, value;
623			while ( elem.length && elem[ 0 ] !== document ) {
624				// Ignore z-index if position is set to a value where z-index is ignored by the browser
625				// This makes behavior of this function consistent across browsers
626				// WebKit always returns auto if the element is positioned
627				position = elem.css( "position" );
628				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
629					// IE returns 0 when zIndex is not specified
630					// other browsers return a string
631					// we ignore the case of nested elements with an explicit value of 0
632					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
633					value = parseInt( elem.css( "zIndex" ), 10 );
634					if ( !isNaN( value ) && value !== 0 ) {
635						return value;
636					}
637				}
638				elem = elem.parent();
639			}
640		}
641
642		return 0;
643	}
644});
645
646// $.ui.plugin is deprecated. Use $.widget() extensions instead.
647$.ui.plugin = {
648	add: function( module, option, set ) {
649		var i,
650			proto = $.ui[ module ].prototype;
651		for ( i in set ) {
652			proto.plugins[ i ] = proto.plugins[ i ] || [];
653			proto.plugins[ i ].push( [ option, set[ i ] ] );
654		}
655	},
656	call: function( instance, name, args, allowDisconnected ) {
657		var i,
658			set = instance.plugins[ name ];
659
660		if ( !set ) {
661			return;
662		}
663
664		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
665			return;
666		}
667
668		for ( i = 0; i < set.length; i++ ) {
669			if ( instance.options[ set[ i ][ 0 ] ] ) {
670				set[ i ][ 1 ].apply( instance.element, args );
671			}
672		}
673	}
674};
675
676
677/*!
678 * jQuery UI Widget 1.11.1
679 * http://jqueryui.com
680 *
681 * Copyright 2014 jQuery Foundation and other contributors
682 * Released under the MIT license.
683 * http://jquery.org/license
684 *
685 * http://api.jqueryui.com/jQuery.widget/
686 */
687
688
689var widget_uuid = 0,
690	widget_slice = Array.prototype.slice;
691
692$.cleanData = (function( orig ) {
693	return function( elems ) {
694		var events, elem, i;
695		for ( i = 0; (elem = elems[i]) != null; i++ ) {
696			try {
697
698				// Only trigger remove when necessary to save time
699				events = $._data( elem, "events" );
700				if ( events && events.remove ) {
701					$( elem ).triggerHandler( "remove" );
702				}
703
704			// http://bugs.jquery.com/ticket/8235
705			} catch( e ) {}
706		}
707		orig( elems );
708	};
709})( $.cleanData );
710
711$.widget = function( name, base, prototype ) {
712	var fullName, existingConstructor, constructor, basePrototype,
713		// proxiedPrototype allows the provided prototype to remain unmodified
714		// so that it can be used as a mixin for multiple widgets (#8876)
715		proxiedPrototype = {},
716		namespace = name.split( "." )[ 0 ];
717
718	name = name.split( "." )[ 1 ];
719	fullName = namespace + "-" + name;
720
721	if ( !prototype ) {
722		prototype = base;
723		base = $.Widget;
724	}
725
726	// create selector for plugin
727	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
728		return !!$.data( elem, fullName );
729	};
730
731	$[ namespace ] = $[ namespace ] || {};
732	existingConstructor = $[ namespace ][ name ];
733	constructor = $[ namespace ][ name ] = function( options, element ) {
734		// allow instantiation without "new" keyword
735		if ( !this._createWidget ) {
736			return new constructor( options, element );
737		}
738
739		// allow instantiation without initializing for simple inheritance
740		// must use "new" keyword (the code above always passes args)
741		if ( arguments.length ) {
742			this._createWidget( options, element );
743		}
744	};
745	// extend with the existing constructor to carry over any static properties
746	$.extend( constructor, existingConstructor, {
747		version: prototype.version,
748		// copy the object used to create the prototype in case we need to
749		// redefine the widget later
750		_proto: $.extend( {}, prototype ),
751		// track widgets that inherit from this widget in case this widget is
752		// redefined after a widget inherits from it
753		_childConstructors: []
754	});
755
756	basePrototype = new base();
757	// we need to make the options hash a property directly on the new instance
758	// otherwise we'll modify the options hash on the prototype that we're
759	// inheriting from
760	basePrototype.options = $.widget.extend( {}, basePrototype.options );
761	$.each( prototype, function( prop, value ) {
762		if ( !$.isFunction( value ) ) {
763			proxiedPrototype[ prop ] = value;
764			return;
765		}
766		proxiedPrototype[ prop ] = (function() {
767			var _super = function() {
768					return base.prototype[ prop ].apply( this, arguments );
769				},
770				_superApply = function( args ) {
771					return base.prototype[ prop ].apply( this, args );
772				};
773			return function() {
774				var __super = this._super,
775					__superApply = this._superApply,
776					returnValue;
777
778				this._super = _super;
779				this._superApply = _superApply;
780
781				returnValue = value.apply( this, arguments );
782
783				this._super = __super;
784				this._superApply = __superApply;
785
786				return returnValue;
787			};
788		})();
789	});
790	constructor.prototype = $.widget.extend( basePrototype, {
791		// TODO: remove support for widgetEventPrefix
792		// always use the name + a colon as the prefix, e.g., draggable:start
793		// don't prefix for widgets that aren't DOM-based
794		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
795	}, proxiedPrototype, {
796		constructor: constructor,
797		namespace: namespace,
798		widgetName: name,
799		widgetFullName: fullName
800	});
801
802	// If this widget is being redefined then we need to find all widgets that
803	// are inheriting from it and redefine all of them so that they inherit from
804	// the new version of this widget. We're essentially trying to replace one
805	// level in the prototype chain.
806	if ( existingConstructor ) {
807		$.each( existingConstructor._childConstructors, function( i, child ) {
808			var childPrototype = child.prototype;
809
810			// redefine the child widget using the same prototype that was
811			// originally used, but inherit from the new version of the base
812			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
813		});
814		// remove the list of existing child constructors from the old constructor
815		// so the old child constructors can be garbage collected
816		delete existingConstructor._childConstructors;
817	} else {
818		base._childConstructors.push( constructor );
819	}
820
821	$.widget.bridge( name, constructor );
822
823	return constructor;
824};
825
826$.widget.extend = function( target ) {
827	var input = widget_slice.call( arguments, 1 ),
828		inputIndex = 0,
829		inputLength = input.length,
830		key,
831		value;
832	for ( ; inputIndex < inputLength; inputIndex++ ) {
833		for ( key in input[ inputIndex ] ) {
834			value = input[ inputIndex ][ key ];
835			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
836				// Clone objects
837				if ( $.isPlainObject( value ) ) {
838					target[ key ] = $.isPlainObject( target[ key ] ) ?
839						$.widget.extend( {}, target[ key ], value ) :
840						// Don't extend strings, arrays, etc. with objects
841						$.widget.extend( {}, value );
842				// Copy everything else by reference
843				} else {
844					target[ key ] = value;
845				}
846			}
847		}
848	}
849	return target;
850};
851
852$.widget.bridge = function( name, object ) {
853	var fullName = object.prototype.widgetFullName || name;
854	$.fn[ name ] = function( options ) {
855		var isMethodCall = typeof options === "string",
856			args = widget_slice.call( arguments, 1 ),
857			returnValue = this;
858
859		// allow multiple hashes to be passed on init
860		options = !isMethodCall && args.length ?
861			$.widget.extend.apply( null, [ options ].concat(args) ) :
862			options;
863
864		if ( isMethodCall ) {
865			this.each(function() {
866				var methodValue,
867					instance = $.data( this, fullName );
868				if ( options === "instance" ) {
869					returnValue = instance;
870					return false;
871				}
872				if ( !instance ) {
873					return $.error( "cannot call methods on " + name + " prior to initialization; " +
874						"attempted to call method '" + options + "'" );
875				}
876				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
877					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
878				}
879				methodValue = instance[ options ].apply( instance, args );
880				if ( methodValue !== instance && methodValue !== undefined ) {
881					returnValue = methodValue && methodValue.jquery ?
882						returnValue.pushStack( methodValue.get() ) :
883						methodValue;
884					return false;
885				}
886			});
887		} else {
888			this.each(function() {
889				var instance = $.data( this, fullName );
890				if ( instance ) {
891					instance.option( options || {} );
892					if ( instance._init ) {
893						instance._init();
894					}
895				} else {
896					$.data( this, fullName, new object( options, this ) );
897				}
898			});
899		}
900
901		return returnValue;
902	};
903};
904
905$.Widget = function( /* options, element */ ) {};
906$.Widget._childConstructors = [];
907
908$.Widget.prototype = {
909	widgetName: "widget",
910	widgetEventPrefix: "",
911	defaultElement: "<div>",
912	options: {
913		disabled: false,
914
915		// callbacks
916		create: null
917	},
918	_createWidget: function( options, element ) {
919		element = $( element || this.defaultElement || this )[ 0 ];
920		this.element = $( element );
921		this.uuid = widget_uuid++;
922		this.eventNamespace = "." + this.widgetName + this.uuid;
923		this.options = $.widget.extend( {},
924			this.options,
925			this._getCreateOptions(),
926			options );
927
928		this.bindings = $();
929		this.hoverable = $();
930		this.focusable = $();
931
932		if ( element !== this ) {
933			$.data( element, this.widgetFullName, this );
934			this._on( true, this.element, {
935				remove: function( event ) {
936					if ( event.target === element ) {
937						this.destroy();
938					}
939				}
940			});
941			this.document = $( element.style ?
942				// element within the document
943				element.ownerDocument :
944				// element is window or document
945				element.document || element );
946			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
947		}
948
949		this._create();
950		this._trigger( "create", null, this._getCreateEventData() );
951		this._init();
952	},
953	_getCreateOptions: $.noop,
954	_getCreateEventData: $.noop,
955	_create: $.noop,
956	_init: $.noop,
957
958	destroy: function() {
959		this._destroy();
960		// we can probably remove the unbind calls in 2.0
961		// all event bindings should go through this._on()
962		this.element
963			.unbind( this.eventNamespace )
964			.removeData( this.widgetFullName )
965			// support: jquery <1.6.3
966			// http://bugs.jquery.com/ticket/9413
967			.removeData( $.camelCase( this.widgetFullName ) );
968		this.widget()
969			.unbind( this.eventNamespace )
970			.removeAttr( "aria-disabled" )
971			.removeClass(
972				this.widgetFullName + "-disabled " +
973				"ui-state-disabled" );
974
975		// clean up events and states
976		this.bindings.unbind( this.eventNamespace );
977		this.hoverable.removeClass( "ui-state-hover" );
978		this.focusable.removeClass( "ui-state-focus" );
979	},
980	_destroy: $.noop,
981
982	widget: function() {
983		return this.element;
984	},
985
986	option: function( key, value ) {
987		var options = key,
988			parts,
989			curOption,
990			i;
991
992		if ( arguments.length === 0 ) {
993			// don't return a reference to the internal hash
994			return $.widget.extend( {}, this.options );
995		}
996
997		if ( typeof key === "string" ) {
998			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
999			options = {};
1000			parts = key.split( "." );
1001			key = parts.shift();
1002			if ( parts.length ) {
1003				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
1004				for ( i = 0; i < parts.length - 1; i++ ) {
1005					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
1006					curOption = curOption[ parts[ i ] ];
1007				}
1008				key = parts.pop();
1009				if ( arguments.length === 1 ) {
1010					return curOption[ key ] === undefined ? null : curOption[ key ];
1011				}
1012				curOption[ key ] = value;
1013			} else {
1014				if ( arguments.length === 1 ) {
1015					return this.options[ key ] === undefined ? null : this.options[ key ];
1016				}
1017				options[ key ] = value;
1018			}
1019		}
1020
1021		this._setOptions( options );
1022
1023		return this;
1024	},
1025	_setOptions: function( options ) {
1026		var key;
1027
1028		for ( key in options ) {
1029			this._setOption( key, options[ key ] );
1030		}
1031
1032		return this;
1033	},
1034	_setOption: function( key, value ) {
1035		this.options[ key ] = value;
1036
1037		if ( key === "disabled" ) {
1038			this.widget()
1039				.toggleClass( this.widgetFullName + "-disabled", !!value );
1040
1041			// If the widget is becoming disabled, then nothing is interactive
1042			if ( value ) {
1043				this.hoverable.removeClass( "ui-state-hover" );
1044				this.focusable.removeClass( "ui-state-focus" );
1045			}
1046		}
1047
1048		return this;
1049	},
1050
1051	enable: function() {
1052		return this._setOptions({ disabled: false });
1053	},
1054	disable: function() {
1055		return this._setOptions({ disabled: true });
1056	},
1057
1058	_on: function( suppressDisabledCheck, element, handlers ) {
1059		var delegateElement,
1060			instance = this;
1061
1062		// no suppressDisabledCheck flag, shuffle arguments
1063		if ( typeof suppressDisabledCheck !== "boolean" ) {
1064			handlers = element;
1065			element = suppressDisabledCheck;
1066			suppressDisabledCheck = false;
1067		}
1068
1069		// no element argument, shuffle and use this.element
1070		if ( !handlers ) {
1071			handlers = element;
1072			element = this.element;
1073			delegateElement = this.widget();
1074		} else {
1075			element = delegateElement = $( element );
1076			this.bindings = this.bindings.add( element );
1077		}
1078
1079		$.each( handlers, function( event, handler ) {
1080			function handlerProxy() {
1081				// allow widgets to customize the disabled handling
1082				// - disabled as an array instead of boolean
1083				// - disabled class as method for disabling individual parts
1084				if ( !suppressDisabledCheck &&
1085						( instance.options.disabled === true ||
1086							$( this ).hasClass( "ui-state-disabled" ) ) ) {
1087					return;
1088				}
1089				return ( typeof handler === "string" ? instance[ handler ] : handler )
1090					.apply( instance, arguments );
1091			}
1092
1093			// copy the guid so direct unbinding works
1094			if ( typeof handler !== "string" ) {
1095				handlerProxy.guid = handler.guid =
1096					handler.guid || handlerProxy.guid || $.guid++;
1097			}
1098
1099			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
1100				eventName = match[1] + instance.eventNamespace,
1101				selector = match[2];
1102			if ( selector ) {
1103				delegateElement.delegate( selector, eventName, handlerProxy );
1104			} else {
1105				element.bind( eventName, handlerProxy );
1106			}
1107		});
1108	},
1109
1110	_off: function( element, eventName ) {
1111		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
1112		element.unbind( eventName ).undelegate( eventName );
1113	},
1114
1115	_delay: function( handler, delay ) {
1116		function handlerProxy() {
1117			return ( typeof handler === "string" ? instance[ handler ] : handler )
1118				.apply( instance, arguments );
1119		}
1120		var instance = this;
1121		return setTimeout( handlerProxy, delay || 0 );
1122	},
1123
1124	_hoverable: function( element ) {
1125		this.hoverable = this.hoverable.add( element );
1126		this._on( element, {
1127			mouseenter: function( event ) {
1128				$( event.currentTarget ).addClass( "ui-state-hover" );
1129			},
1130			mouseleave: function( event ) {
1131				$( event.currentTarget ).removeClass( "ui-state-hover" );
1132			}
1133		});
1134	},
1135
1136	_focusable: function( element ) {
1137		this.focusable = this.focusable.add( element );
1138		this._on( element, {
1139			focusin: function( event ) {
1140				$( event.currentTarget ).addClass( "ui-state-focus" );
1141			},
1142			focusout: function( event ) {
1143				$( event.currentTarget ).removeClass( "ui-state-focus" );
1144			}
1145		});
1146	},
1147
1148	_trigger: function( type, event, data ) {
1149		var prop, orig,
1150			callback = this.options[ type ];
1151
1152		data = data || {};
1153		event = $.Event( event );
1154		event.type = ( type === this.widgetEventPrefix ?
1155			type :
1156			this.widgetEventPrefix + type ).toLowerCase();
1157		// the original event may come from any element
1158		// so we need to reset the target on the new event
1159		event.target = this.element[ 0 ];
1160
1161		// copy original event properties over to the new event
1162		orig = event.originalEvent;
1163		if ( orig ) {
1164			for ( prop in orig ) {
1165				if ( !( prop in event ) ) {
1166					event[ prop ] = orig[ prop ];
1167				}
1168			}
1169		}
1170
1171		this.element.trigger( event, data );
1172		return !( $.isFunction( callback ) &&
1173			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
1174			event.isDefaultPrevented() );
1175	}
1176};
1177
1178$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
1179	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
1180		if ( typeof options === "string" ) {
1181			options = { effect: options };
1182		}
1183		var hasOptions,
1184			effectName = !options ?
1185				method :
1186				options === true || typeof options === "number" ?
1187					defaultEffect :
1188					options.effect || defaultEffect;
1189		options = options || {};
1190		if ( typeof options === "number" ) {
1191			options = { duration: options };
1192		}
1193		hasOptions = !$.isEmptyObject( options );
1194		options.complete = callback;
1195		if ( options.delay ) {
1196			element.delay( options.delay );
1197		}
1198		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
1199			element[ method ]( options );
1200		} else if ( effectName !== method && element[ effectName ] ) {
1201			element[ effectName ]( options.duration, options.easing, callback );
1202		} else {
1203			element.queue(function( next ) {
1204				$( this )[ method ]();
1205				if ( callback ) {
1206					callback.call( element[ 0 ] );
1207				}
1208				next();
1209			});
1210		}
1211	};
1212});
1213
1214var widget = $.widget;
1215
1216
1217/*!
1218 * jQuery UI Mouse 1.11.1
1219 * http://jqueryui.com
1220 *
1221 * Copyright 2014 jQuery Foundation and other contributors
1222 * Released under the MIT license.
1223 * http://jquery.org/license
1224 *
1225 * http://api.jqueryui.com/mouse/
1226 */
1227
1228
1229var mouseHandled = false;
1230$( document ).mouseup( function() {
1231	mouseHandled = false;
1232});
1233
1234var mouse = $.widget("ui.mouse", {
1235	version: "1.11.1",
1236	options: {
1237		cancel: "input,textarea,button,select,option",
1238		distance: 1,
1239		delay: 0
1240	},
1241	_mouseInit: function() {
1242		var that = this;
1243
1244		this.element
1245			.bind("mousedown." + this.widgetName, function(event) {
1246				return that._mouseDown(event);
1247			})
1248			.bind("click." + this.widgetName, function(event) {
1249				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
1250					$.removeData(event.target, that.widgetName + ".preventClickEvent");
1251					event.stopImmediatePropagation();
1252					return false;
1253				}
1254			});
1255
1256		this.started = false;
1257	},
1258
1259	// TODO: make sure destroying one instance of mouse doesn't mess with
1260	// other instances of mouse
1261	_mouseDestroy: function() {
1262		this.element.unbind("." + this.widgetName);
1263		if ( this._mouseMoveDelegate ) {
1264			this.document
1265				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
1266				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
1267		}
1268	},
1269
1270	_mouseDown: function(event) {
1271		// don't let more than one widget handle mouseStart
1272		if ( mouseHandled ) {
1273			return;
1274		}
1275
1276		// we may have missed mouseup (out of window)
1277		(this._mouseStarted && this._mouseUp(event));
1278
1279		this._mouseDownEvent = event;
1280
1281		var that = this,
1282			btnIsLeft = (event.which === 1),
1283			// event.target.nodeName works around a bug in IE 8 with
1284			// disabled inputs (#7620)
1285			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
1286		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
1287			return true;
1288		}
1289
1290		this.mouseDelayMet = !this.options.delay;
1291		if (!this.mouseDelayMet) {
1292			this._mouseDelayTimer = setTimeout(function() {
1293				that.mouseDelayMet = true;
1294			}, this.options.delay);
1295		}
1296
1297		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
1298			this._mouseStarted = (this._mouseStart(event) !== false);
1299			if (!this._mouseStarted) {
1300				event.preventDefault();
1301				return true;
1302			}
1303		}
1304
1305		// Click event may never have fired (Gecko & Opera)
1306		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
1307			$.removeData(event.target, this.widgetName + ".preventClickEvent");
1308		}
1309
1310		// these delegates are required to keep context
1311		this._mouseMoveDelegate = function(event) {
1312			return that._mouseMove(event);
1313		};
1314		this._mouseUpDelegate = function(event) {
1315			return that._mouseUp(event);
1316		};
1317
1318		this.document
1319			.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1320			.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1321
1322		event.preventDefault();
1323
1324		mouseHandled = true;
1325		return true;
1326	},
1327
1328	_mouseMove: function(event) {
1329		// IE mouseup check - mouseup happened when mouse was out of window
1330		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
1331			return this._mouseUp(event);
1332
1333		// Iframe mouseup check - mouseup occurred in another document
1334		} else if ( !event.which ) {
1335			return this._mouseUp( event );
1336		}
1337
1338		if (this._mouseStarted) {
1339			this._mouseDrag(event);
1340			return event.preventDefault();
1341		}
1342
1343		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
1344			this._mouseStarted =
1345				(this._mouseStart(this._mouseDownEvent, event) !== false);
1346			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1347		}
1348
1349		return !this._mouseStarted;
1350	},
1351
1352	_mouseUp: function(event) {
1353		this.document
1354			.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1355			.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1356
1357		if (this._mouseStarted) {
1358			this._mouseStarted = false;
1359
1360			if (event.target === this._mouseDownEvent.target) {
1361				$.data(event.target, this.widgetName + ".preventClickEvent", true);
1362			}
1363
1364			this._mouseStop(event);
1365		}
1366
1367		mouseHandled = false;
1368		return false;
1369	},
1370
1371	_mouseDistanceMet: function(event) {
1372		return (Math.max(
1373				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1374				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1375			) >= this.options.distance
1376		);
1377	},
1378
1379	_mouseDelayMet: function(/* event */) {
1380		return this.mouseDelayMet;
1381	},
1382
1383	// These are placeholder methods, to be overriden by extending plugin
1384	_mouseStart: function(/* event */) {},
1385	_mouseDrag: function(/* event */) {},
1386	_mouseStop: function(/* event */) {},
1387	_mouseCapture: function(/* event */) { return true; }
1388});
1389
1390
1391/*!
1392 * jQuery UI Position 1.11.1
1393 * http://jqueryui.com
1394 *
1395 * Copyright 2014 jQuery Foundation and other contributors
1396 * Released under the MIT license.
1397 * http://jquery.org/license
1398 *
1399 * http://api.jqueryui.com/position/
1400 */
1401
1402(function() {
1403
1404$.ui = $.ui || {};
1405
1406var cachedScrollbarWidth, supportsOffsetFractions,
1407	max = Math.max,
1408	abs = Math.abs,
1409	round = Math.round,
1410	rhorizontal = /left|center|right/,
1411	rvertical = /top|center|bottom/,
1412	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1413	rposition = /^\w+/,
1414	rpercent = /%$/,
1415	_position = $.fn.position;
1416
1417function getOffsets( offsets, width, height ) {
1418	return [
1419		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1420		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1421	];
1422}
1423
1424function parseCss( element, property ) {
1425	return parseInt( $.css( element, property ), 10 ) || 0;
1426}
1427
1428function getDimensions( elem ) {
1429	var raw = elem[0];
1430	if ( raw.nodeType === 9 ) {
1431		return {
1432			width: elem.width(),
1433			height: elem.height(),
1434			offset: { top: 0, left: 0 }
1435		};
1436	}
1437	if ( $.isWindow( raw ) ) {
1438		return {
1439			width: elem.width(),
1440			height: elem.height(),
1441			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1442		};
1443	}
1444	if ( raw.preventDefault ) {
1445		return {
1446			width: 0,
1447			height: 0,
1448			offset: { top: raw.pageY, left: raw.pageX }
1449		};
1450	}
1451	return {
1452		width: elem.outerWidth(),
1453		height: elem.outerHeight(),
1454		offset: elem.offset()
1455	};
1456}
1457
1458$.position = {
1459	scrollbarWidth: function() {
1460		if ( cachedScrollbarWidth !== undefined ) {
1461			return cachedScrollbarWidth;
1462		}
1463		var w1, w2,
1464			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1465			innerDiv = div.children()[0];
1466
1467		$( "body" ).append( div );
1468		w1 = innerDiv.offsetWidth;
1469		div.css( "overflow", "scroll" );
1470
1471		w2 = innerDiv.offsetWidth;
1472
1473		if ( w1 === w2 ) {
1474			w2 = div[0].clientWidth;
1475		}
1476
1477		div.remove();
1478
1479		return (cachedScrollbarWidth = w1 - w2);
1480	},
1481	getScrollInfo: function( within ) {
1482		var overflowX = within.isWindow || within.isDocument ? "" :
1483				within.element.css( "overflow-x" ),
1484			overflowY = within.isWindow || within.isDocument ? "" :
1485				within.element.css( "overflow-y" ),
1486			hasOverflowX = overflowX === "scroll" ||
1487				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1488			hasOverflowY = overflowY === "scroll" ||
1489				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1490		return {
1491			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1492			height: hasOverflowX ? $.position.scrollbarWidth() : 0
1493		};
1494	},
1495	getWithinInfo: function( element ) {
1496		var withinElement = $( element || window ),
1497			isWindow = $.isWindow( withinElement[0] ),
1498			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1499		return {
1500			element: withinElement,
1501			isWindow: isWindow,
1502			isDocument: isDocument,
1503			offset: withinElement.offset() || { left: 0, top: 0 },
1504			scrollLeft: withinElement.scrollLeft(),
1505			scrollTop: withinElement.scrollTop(),
1506
1507			// support: jQuery 1.6.x
1508			// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1509			width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1510			height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1511		};
1512	}
1513};
1514
1515$.fn.position = function( options ) {
1516	if ( !options || !options.of ) {
1517		return _position.apply( this, arguments );
1518	}
1519
1520	// make a copy, we don't want to modify arguments
1521	options = $.extend( {}, options );
1522
1523	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1524		target = $( options.of ),
1525		within = $.position.getWithinInfo( options.within ),
1526		scrollInfo = $.position.getScrollInfo( within ),
1527		collision = ( options.collision || "flip" ).split( " " ),
1528		offsets = {};
1529
1530	dimensions = getDimensions( target );
1531	if ( target[0].preventDefault ) {
1532		// force left top to allow flipping
1533		options.at = "left top";
1534	}
1535	targetWidth = dimensions.width;
1536	targetHeight = dimensions.height;
1537	targetOffset = dimensions.offset;
1538	// clone to reuse original targetOffset later
1539	basePosition = $.extend( {}, targetOffset );
1540
1541	// force my and at to have valid horizontal and vertical positions
1542	// if a value is missing or invalid, it will be converted to center
1543	$.each( [ "my", "at" ], function() {
1544		var pos = ( options[ this ] || "" ).split( " " ),
1545			horizontalOffset,
1546			verticalOffset;
1547
1548		if ( pos.length === 1) {
1549			pos = rhorizontal.test( pos[ 0 ] ) ?
1550				pos.concat( [ "center" ] ) :
1551				rvertical.test( pos[ 0 ] ) ?
1552					[ "center" ].concat( pos ) :
1553					[ "center", "center" ];
1554		}
1555		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1556		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1557
1558		// calculate offsets
1559		horizontalOffset = roffset.exec( pos[ 0 ] );
1560		verticalOffset = roffset.exec( pos[ 1 ] );
1561		offsets[ this ] = [
1562			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1563			verticalOffset ? verticalOffset[ 0 ] : 0
1564		];
1565
1566		// reduce to just the positions without the offsets
1567		options[ this ] = [
1568			rposition.exec( pos[ 0 ] )[ 0 ],
1569			rposition.exec( pos[ 1 ] )[ 0 ]
1570		];
1571	});
1572
1573	// normalize collision option
1574	if ( collision.length === 1 ) {
1575		collision[ 1 ] = collision[ 0 ];
1576	}
1577
1578	if ( options.at[ 0 ] === "right" ) {
1579		basePosition.left += targetWidth;
1580	} else if ( options.at[ 0 ] === "center" ) {
1581		basePosition.left += targetWidth / 2;
1582	}
1583
1584	if ( options.at[ 1 ] === "bottom" ) {
1585		basePosition.top += targetHeight;
1586	} else if ( options.at[ 1 ] === "center" ) {
1587		basePosition.top += targetHeight / 2;
1588	}
1589
1590	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1591	basePosition.left += atOffset[ 0 ];
1592	basePosition.top += atOffset[ 1 ];
1593
1594	return this.each(function() {
1595		var collisionPosition, using,
1596			elem = $( this ),
1597			elemWidth = elem.outerWidth(),
1598			elemHeight = elem.outerHeight(),
1599			marginLeft = parseCss( this, "marginLeft" ),
1600			marginTop = parseCss( this, "marginTop" ),
1601			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1602			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1603			position = $.extend( {}, basePosition ),
1604			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1605
1606		if ( options.my[ 0 ] === "right" ) {
1607			position.left -= elemWidth;
1608		} else if ( options.my[ 0 ] === "center" ) {
1609			position.left -= elemWidth / 2;
1610		}
1611
1612		if ( options.my[ 1 ] === "bottom" ) {
1613			position.top -= elemHeight;
1614		} else if ( options.my[ 1 ] === "center" ) {
1615			position.top -= elemHeight / 2;
1616		}
1617
1618		position.left += myOffset[ 0 ];
1619		position.top += myOffset[ 1 ];
1620
1621		// if the browser doesn't support fractions, then round for consistent results
1622		if ( !supportsOffsetFractions ) {
1623			position.left = round( position.left );
1624			position.top = round( position.top );
1625		}
1626
1627		collisionPosition = {
1628			marginLeft: marginLeft,
1629			marginTop: marginTop
1630		};
1631
1632		$.each( [ "left", "top" ], function( i, dir ) {
1633			if ( $.ui.position[ collision[ i ] ] ) {
1634				$.ui.position[ collision[ i ] ][ dir ]( position, {
1635					targetWidth: targetWidth,
1636					targetHeight: targetHeight,
1637					elemWidth: elemWidth,
1638					elemHeight: elemHeight,
1639					collisionPosition: collisionPosition,
1640					collisionWidth: collisionWidth,
1641					collisionHeight: collisionHeight,
1642					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1643					my: options.my,
1644					at: options.at,
1645					within: within,
1646					elem: elem
1647				});
1648			}
1649		});
1650
1651		if ( options.using ) {
1652			// adds feedback as second argument to using callback, if present
1653			using = function( props ) {
1654				var left = targetOffset.left - position.left,
1655					right = left + targetWidth - elemWidth,
1656					top = targetOffset.top - position.top,
1657					bottom = top + targetHeight - elemHeight,
1658					feedback = {
1659						target: {
1660							element: target,
1661							left: targetOffset.left,
1662							top: targetOffset.top,
1663							width: targetWidth,
1664							height: targetHeight
1665						},
1666						element: {
1667							element: elem,
1668							left: position.left,
1669							top: position.top,
1670							width: elemWidth,
1671							height: elemHeight
1672						},
1673						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1674						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1675					};
1676				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1677					feedback.horizontal = "center";
1678				}
1679				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1680					feedback.vertical = "middle";
1681				}
1682				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1683					feedback.important = "horizontal";
1684				} else {
1685					feedback.important = "vertical";
1686				}
1687				options.using.call( this, props, feedback );
1688			};
1689		}
1690
1691		elem.offset( $.extend( position, { using: using } ) );
1692	});
1693};
1694
1695$.ui.position = {
1696	fit: {
1697		left: function( position, data ) {
1698			var within = data.within,
1699				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1700				outerWidth = within.width,
1701				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1702				overLeft = withinOffset - collisionPosLeft,
1703				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1704				newOverRight;
1705
1706			// element is wider than within
1707			if ( data.collisionWidth > outerWidth ) {
1708				// element is initially over the left side of within
1709				if ( overLeft > 0 && overRight <= 0 ) {
1710					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1711					position.left += overLeft - newOverRight;
1712				// element is initially over right side of within
1713				} else if ( overRight > 0 && overLeft <= 0 ) {
1714					position.left = withinOffset;
1715				// element is initially over both left and right sides of within
1716				} else {
1717					if ( overLeft > overRight ) {
1718						position.left = withinOffset + outerWidth - data.collisionWidth;
1719					} else {
1720						position.left = withinOffset;
1721					}
1722				}
1723			// too far left -> align with left edge
1724			} else if ( overLeft > 0 ) {
1725				position.left += overLeft;
1726			// too far right -> align with right edge
1727			} else if ( overRight > 0 ) {
1728				position.left -= overRight;
1729			// adjust based on position and margin
1730			} else {
1731				position.left = max( position.left - collisionPosLeft, position.left );
1732			}
1733		},
1734		top: function( position, data ) {
1735			var within = data.within,
1736				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1737				outerHeight = data.within.height,
1738				collisionPosTop = position.top - data.collisionPosition.marginTop,
1739				overTop = withinOffset - collisionPosTop,
1740				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1741				newOverBottom;
1742
1743			// element is taller than within
1744			if ( data.collisionHeight > outerHeight ) {
1745				// element is initially over the top of within
1746				if ( overTop > 0 && overBottom <= 0 ) {
1747					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1748					position.top += overTop - newOverBottom;
1749				// element is initially over bottom of within
1750				} else if ( overBottom > 0 && overTop <= 0 ) {
1751					position.top = withinOffset;
1752				// element is initially over both top and bottom of within
1753				} else {
1754					if ( overTop > overBottom ) {
1755						position.top = withinOffset + outerHeight - data.collisionHeight;
1756					} else {
1757						position.top = withinOffset;
1758					}
1759				}
1760			// too far up -> align with top
1761			} else if ( overTop > 0 ) {
1762				position.top += overTop;
1763			// too far down -> align with bottom edge
1764			} else if ( overBottom > 0 ) {
1765				position.top -= overBottom;
1766			// adjust based on position and margin
1767			} else {
1768				position.top = max( position.top - collisionPosTop, position.top );
1769			}
1770		}
1771	},
1772	flip: {
1773		left: function( position, data ) {
1774			var within = data.within,
1775				withinOffset = within.offset.left + within.scrollLeft,
1776				outerWidth = within.width,
1777				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1778				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1779				overLeft = collisionPosLeft - offsetLeft,
1780				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1781				myOffset = data.my[ 0 ] === "left" ?
1782					-data.elemWidth :
1783					data.my[ 0 ] === "right" ?
1784						data.elemWidth :
1785						0,
1786				atOffset = data.at[ 0 ] === "left" ?
1787					data.targetWidth :
1788					data.at[ 0 ] === "right" ?
1789						-data.targetWidth :
1790						0,
1791				offset = -2 * data.offset[ 0 ],
1792				newOverRight,
1793				newOverLeft;
1794
1795			if ( overLeft < 0 ) {
1796				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1797				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1798					position.left += myOffset + atOffset + offset;
1799				}
1800			} else if ( overRight > 0 ) {
1801				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1802				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1803					position.left += myOffset + atOffset + offset;
1804				}
1805			}
1806		},
1807		top: function( position, data ) {
1808			var within = data.within,
1809				withinOffset = within.offset.top + within.scrollTop,
1810				outerHeight = within.height,
1811				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1812				collisionPosTop = position.top - data.collisionPosition.marginTop,
1813				overTop = collisionPosTop - offsetTop,
1814				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1815				top = data.my[ 1 ] === "top",
1816				myOffset = top ?
1817					-data.elemHeight :
1818					data.my[ 1 ] === "bottom" ?
1819						data.elemHeight :
1820						0,
1821				atOffset = data.at[ 1 ] === "top" ?
1822					data.targetHeight :
1823					data.at[ 1 ] === "bottom" ?
1824						-data.targetHeight :
1825						0,
1826				offset = -2 * data.offset[ 1 ],
1827				newOverTop,
1828				newOverBottom;
1829			if ( overTop < 0 ) {
1830				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1831				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1832					position.top += myOffset + atOffset + offset;
1833				}
1834			} else if ( overBottom > 0 ) {
1835				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1836				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1837					position.top += myOffset + atOffset + offset;
1838				}
1839			}
1840		}
1841	},
1842	flipfit: {
1843		left: function() {
1844			$.ui.position.flip.left.apply( this, arguments );
1845			$.ui.position.fit.left.apply( this, arguments );
1846		},
1847		top: function() {
1848			$.ui.position.flip.top.apply( this, arguments );
1849			$.ui.position.fit.top.apply( this, arguments );
1850		}
1851	}
1852};
1853
1854// fraction support test
1855(function() {
1856	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1857		body = document.getElementsByTagName( "body" )[ 0 ],
1858		div = document.createElement( "div" );
1859
1860	//Create a "fake body" for testing based on method used in jQuery.support
1861	testElement = document.createElement( body ? "div" : "body" );
1862	testElementStyle = {
1863		visibility: "hidden",
1864		width: 0,
1865		height: 0,
1866		border: 0,
1867		margin: 0,
1868		background: "none"
1869	};
1870	if ( body ) {
1871		$.extend( testElementStyle, {
1872			position: "absolute",
1873			left: "-1000px",
1874			top: "-1000px"
1875		});
1876	}
1877	for ( i in testElementStyle ) {
1878		testElement.style[ i ] = testElementStyle[ i ];
1879	}
1880	testElement.appendChild( div );
1881	testElementParent = body || document.documentElement;
1882	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1883
1884	div.style.cssText = "position: absolute; left: 10.7432222px;";
1885
1886	offsetLeft = $( div ).offset().left;
1887	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1888
1889	testElement.innerHTML = "";
1890	testElementParent.removeChild( testElement );
1891})();
1892
1893})();
1894
1895var position = $.ui.position;
1896
1897
1898/*!
1899 * jQuery UI Accordion 1.11.1
1900 * http://jqueryui.com
1901 *
1902 * Copyright 2014 jQuery Foundation and other contributors
1903 * Released under the MIT license.
1904 * http://jquery.org/license
1905 *
1906 * http://api.jqueryui.com/accordion/
1907 */
1908
1909
1910var accordion = $.widget( "ui.accordion", {
1911	version: "1.11.1",
1912	options: {
1913		active: 0,
1914		animate: {},
1915		collapsible: false,
1916		event: "click",
1917		header: "> li > :first-child,> :not(li):even",
1918		heightStyle: "auto",
1919		icons: {
1920			activeHeader: "ui-icon-triangle-1-s",
1921			header: "ui-icon-triangle-1-e"
1922		},
1923
1924		// callbacks
1925		activate: null,
1926		beforeActivate: null
1927	},
1928
1929	hideProps: {
1930		borderTopWidth: "hide",
1931		borderBottomWidth: "hide",
1932		paddingTop: "hide",
1933		paddingBottom: "hide",
1934		height: "hide"
1935	},
1936
1937	showProps: {
1938		borderTopWidth: "show",
1939		borderBottomWidth: "show",
1940		paddingTop: "show",
1941		paddingBottom: "show",
1942		height: "show"
1943	},
1944
1945	_create: function() {
1946		var options = this.options;
1947		this.prevShow = this.prevHide = $();
1948		this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1949			// ARIA
1950			.attr( "role", "tablist" );
1951
1952		// don't allow collapsible: false and active: false / null
1953		if ( !options.collapsible && (options.active === false || options.active == null) ) {
1954			options.active = 0;
1955		}
1956
1957		this._processPanels();
1958		// handle negative values
1959		if ( options.active < 0 ) {
1960			options.active += this.headers.length;
1961		}
1962		this._refresh();
1963	},
1964
1965	_getCreateEventData: function() {
1966		return {
1967			header: this.active,
1968			panel: !this.active.length ? $() : this.active.next()
1969		};
1970	},
1971
1972	_createIcons: function() {
1973		var icons = this.options.icons;
1974		if ( icons ) {
1975			$( "<span>" )
1976				.addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1977				.prependTo( this.headers );
1978			this.active.children( ".ui-accordion-header-icon" )
1979				.removeClass( icons.header )
1980				.addClass( icons.activeHeader );
1981			this.headers.addClass( "ui-accordion-icons" );
1982		}
1983	},
1984
1985	_destroyIcons: function() {
1986		this.headers
1987			.removeClass( "ui-accordion-icons" )
1988			.children( ".ui-accordion-header-icon" )
1989				.remove();
1990	},
1991
1992	_destroy: function() {
1993		var contents;
1994
1995		// clean up main element
1996		this.element
1997			.removeClass( "ui-accordion ui-widget ui-helper-reset" )
1998			.removeAttr( "role" );
1999
2000		// clean up headers
2001		this.headers
2002			.removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
2003				"ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
2004			.removeAttr( "role" )
2005			.removeAttr( "aria-expanded" )
2006			.removeAttr( "aria-selected" )
2007			.removeAttr( "aria-controls" )
2008			.removeAttr( "tabIndex" )
2009			.removeUniqueId();
2010
2011		this._destroyIcons();
2012
2013		// clean up content panels
2014		contents = this.headers.next()
2015			.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
2016				"ui-accordion-content ui-accordion-content-active ui-state-disabled" )
2017			.css( "display", "" )
2018			.removeAttr( "role" )
2019			.removeAttr( "aria-hidden" )
2020			.removeAttr( "aria-labelledby" )
2021			.removeUniqueId();
2022
2023		if ( this.options.heightStyle !== "content" ) {
2024			contents.css( "height", "" );
2025		}
2026	},
2027
2028	_setOption: function( key, value ) {
2029		if ( key === "active" ) {
2030			// _activate() will handle invalid values and update this.options
2031			this._activate( value );
2032			return;
2033		}
2034
2035		if ( key === "event" ) {
2036			if ( this.options.event ) {
2037				this._off( this.headers, this.options.event );
2038			}
2039			this._setupEvents( value );
2040		}
2041
2042		this._super( key, value );
2043
2044		// setting collapsible: false while collapsed; open first panel
2045		if ( key === "collapsible" && !value && this.options.active === false ) {
2046			this._activate( 0 );
2047		}
2048
2049		if ( key === "icons" ) {
2050			this._destroyIcons();
2051			if ( value ) {
2052				this._createIcons();
2053			}
2054		}
2055
2056		// #5332 - opacity doesn't cascade to positioned elements in IE
2057		// so we need to add the disabled class to the headers and panels
2058		if ( key === "disabled" ) {
2059			this.element
2060				.toggleClass( "ui-state-disabled", !!value )
2061				.attr( "aria-disabled", value );
2062			this.headers.add( this.headers.next() )
2063				.toggleClass( "ui-state-disabled", !!value );
2064		}
2065	},
2066
2067	_keydown: function( event ) {
2068		if ( event.altKey || event.ctrlKey ) {
2069			return;
2070		}
2071
2072		var keyCode = $.ui.keyCode,
2073			length = this.headers.length,
2074			currentIndex = this.headers.index( event.target ),
2075			toFocus = false;
2076
2077		switch ( event.keyCode ) {
2078			case keyCode.RIGHT:
2079			case keyCode.DOWN:
2080				toFocus = this.headers[ ( currentIndex + 1 ) % length ];
2081				break;
2082			case keyCode.LEFT:
2083			case keyCode.UP:
2084				toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
2085				break;
2086			case keyCode.SPACE:
2087			case keyCode.ENTER:
2088				this._eventHandler( event );
2089				break;
2090			case keyCode.HOME:
2091				toFocus = this.headers[ 0 ];
2092				break;
2093			case keyCode.END:
2094				toFocus = this.headers[ length - 1 ];
2095				break;
2096		}
2097
2098		if ( toFocus ) {
2099			$( event.target ).attr( "tabIndex", -1 );
2100			$( toFocus ).attr( "tabIndex", 0 );
2101			toFocus.focus();
2102			event.preventDefault();
2103		}
2104	},
2105
2106	_panelKeyDown: function( event ) {
2107		if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
2108			$( event.currentTarget ).prev().focus();
2109		}
2110	},
2111
2112	refresh: function() {
2113		var options = this.options;
2114		this._processPanels();
2115
2116		// was collapsed or no panel
2117		if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
2118			options.active = false;
2119			this.active = $();
2120		// active false only when collapsible is true
2121		} else if ( options.active === false ) {
2122			this._activate( 0 );
2123		// was active, but active panel is gone
2124		} else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2125			// all remaining panel are disabled
2126			if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
2127				options.active = false;
2128				this.active = $();
2129			// activate previous panel
2130			} else {
2131				this._activate( Math.max( 0, options.active - 1 ) );
2132			}
2133		// was active, active panel still exists
2134		} else {
2135			// make sure active index is correct
2136			options.active = this.headers.index( this.active );
2137		}
2138
2139		this._destroyIcons();
2140
2141		this._refresh();
2142	},
2143
2144	_processPanels: function() {
2145		this.headers = this.element.find( this.options.header )
2146			.addClass( "ui-accordion-header ui-state-default ui-corner-all" );
2147
2148		this.headers.next()
2149			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
2150			.filter( ":not(.ui-accordion-content-active)" )
2151			.hide();
2152	},
2153
2154	_refresh: function() {
2155		var maxHeight,
2156			options = this.options,
2157			heightStyle = options.heightStyle,
2158			parent = this.element.parent();
2159
2160		this.active = this._findActive( options.active )
2161			.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
2162			.removeClass( "ui-corner-all" );
2163		this.active.next()
2164			.addClass( "ui-accordion-content-active" )
2165			.show();
2166
2167		this.headers
2168			.attr( "role", "tab" )
2169			.each(function() {
2170				var header = $( this ),
2171					headerId = header.uniqueId().attr( "id" ),
2172					panel = header.next(),
2173					panelId = panel.uniqueId().attr( "id" );
2174				header.attr( "aria-controls", panelId );
2175				panel.attr( "aria-labelledby", headerId );
2176			})
2177			.next()
2178				.attr( "role", "tabpanel" );
2179
2180		this.headers
2181			.not( this.active )
2182			.attr({
2183				"aria-selected": "false",
2184				"aria-expanded": "false",
2185				tabIndex: -1
2186			})
2187			.next()
2188				.attr({
2189					"aria-hidden": "true"
2190				})
2191				.hide();
2192
2193		// make sure at least one header is in the tab order
2194		if ( !this.active.length ) {
2195			this.headers.eq( 0 ).attr( "tabIndex", 0 );
2196		} else {
2197			this.active.attr({
2198				"aria-selected": "true",
2199				"aria-expanded": "true",
2200				tabIndex: 0
2201			})
2202			.next()
2203				.attr({
2204					"aria-hidden": "false"
2205				});
2206		}
2207
2208		this._createIcons();
2209
2210		this._setupEvents( options.event );
2211
2212		if ( heightStyle === "fill" ) {
2213			maxHeight = parent.height();
2214			this.element.siblings( ":visible" ).each(function() {
2215				var elem = $( this ),
2216					position = elem.css( "position" );
2217
2218				if ( position === "absolute" || position === "fixed" ) {
2219					return;
2220				}
2221				maxHeight -= elem.outerHeight( true );
2222			});
2223
2224			this.headers.each(function() {
2225				maxHeight -= $( this ).outerHeight( true );
2226			});
2227
2228			this.headers.next()
2229				.each(function() {
2230					$( this ).height( Math.max( 0, maxHeight -
2231						$( this ).innerHeight() + $( this ).height() ) );
2232				})
2233				.css( "overflow", "auto" );
2234		} else if ( heightStyle === "auto" ) {
2235			maxHeight = 0;
2236			this.headers.next()
2237				.each(function() {
2238					maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
2239				})
2240				.height( maxHeight );
2241		}
2242	},
2243
2244	_activate: function( index ) {
2245		var active = this._findActive( index )[ 0 ];
2246
2247		// trying to activate the already active panel
2248		if ( active === this.active[ 0 ] ) {
2249			return;
2250		}
2251
2252		// trying to collapse, simulate a click on the currently active header
2253		active = active || this.active[ 0 ];
2254
2255		this._eventHandler({
2256			target: active,
2257			currentTarget: active,
2258			preventDefault: $.noop
2259		});
2260	},
2261
2262	_findActive: function( selector ) {
2263		return typeof selector === "number" ? this.headers.eq( selector ) : $();
2264	},
2265
2266	_setupEvents: function( event ) {
2267		var events = {
2268			keydown: "_keydown"
2269		};
2270		if ( event ) {
2271			$.each( event.split( " " ), function( index, eventName ) {
2272				events[ eventName ] = "_eventHandler";
2273			});
2274		}
2275
2276		this._off( this.headers.add( this.headers.next() ) );
2277		this._on( this.headers, events );
2278		this._on( this.headers.next(), { keydown: "_panelKeyDown" });
2279		this._hoverable( this.headers );
2280		this._focusable( this.headers );
2281	},
2282
2283	_eventHandler: function( event ) {
2284		var options = this.options,
2285			active = this.active,
2286			clicked = $( event.currentTarget ),
2287			clickedIsActive = clicked[ 0 ] === active[ 0 ],
2288			collapsing = clickedIsActive && options.collapsible,
2289			toShow = collapsing ? $() : clicked.next(),
2290			toHide = active.next(),
2291			eventData = {
2292				oldHeader: active,
2293				oldPanel: toHide,
2294				newHeader: collapsing ? $() : clicked,
2295				newPanel: toShow
2296			};
2297
2298		event.preventDefault();
2299
2300		if (
2301				// click on active header, but not collapsible
2302				( clickedIsActive && !options.collapsible ) ||
2303				// allow canceling activation
2304				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
2305			return;
2306		}
2307
2308		options.active = collapsing ? false : this.headers.index( clicked );
2309
2310		// when the call to ._toggle() comes after the class changes
2311		// it causes a very odd bug in IE 8 (see #6720)
2312		this.active = clickedIsActive ? $() : clicked;
2313		this._toggle( eventData );
2314
2315		// switch classes
2316		// corner classes on the previously active header stay after the animation
2317		active.removeClass( "ui-accordion-header-active ui-state-active" );
2318		if ( options.icons ) {
2319			active.children( ".ui-accordion-header-icon" )
2320				.removeClass( options.icons.activeHeader )
2321				.addClass( options.icons.header );
2322		}
2323
2324		if ( !clickedIsActive ) {
2325			clicked
2326				.removeClass( "ui-corner-all" )
2327				.addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
2328			if ( options.icons ) {
2329				clicked.children( ".ui-accordion-header-icon" )
2330					.removeClass( options.icons.header )
2331					.addClass( options.icons.activeHeader );
2332			}
2333
2334			clicked
2335				.next()
2336				.addClass( "ui-accordion-content-active" );
2337		}
2338	},
2339
2340	_toggle: function( data ) {
2341		var toShow = data.newPanel,
2342			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2343
2344		// handle activating a panel during the animation for another activation
2345		this.prevShow.add( this.prevHide ).stop( true, true );
2346		this.prevShow = toShow;
2347		this.prevHide = toHide;
2348
2349		if ( this.options.animate ) {
2350			this._animate( toShow, toHide, data );
2351		} else {
2352			toHide.hide();
2353			toShow.show();
2354			this._toggleComplete( data );
2355		}
2356
2357		toHide.attr({
2358			"aria-hidden": "true"
2359		});
2360		toHide.prev().attr( "aria-selected", "false" );
2361		// if we're switching panels, remove the old header from the tab order
2362		// if we're opening from collapsed state, remove the previous header from the tab order
2363		// if we're collapsing, then keep the collapsing header in the tab order
2364		if ( toShow.length && toHide.length ) {
2365			toHide.prev().attr({
2366				"tabIndex": -1,
2367				"aria-expanded": "false"
2368			});
2369		} else if ( toShow.length ) {
2370			this.headers.filter(function() {
2371				return $( this ).attr( "tabIndex" ) === 0;
2372			})
2373			.attr( "tabIndex", -1 );
2374		}
2375
2376		toShow
2377			.attr( "aria-hidden", "false" )
2378			.prev()
2379				.attr({
2380					"aria-selected": "true",
2381					tabIndex: 0,
2382					"aria-expanded": "true"
2383				});
2384	},
2385
2386	_animate: function( toShow, toHide, data ) {
2387		var total, easing, duration,
2388			that = this,
2389			adjust = 0,
2390			down = toShow.length &&
2391				( !toHide.length || ( toShow.index() < toHide.index() ) ),
2392			animate = this.options.animate || {},
2393			options = down && animate.down || animate,
2394			complete = function() {
2395				that._toggleComplete( data );
2396			};
2397
2398		if ( typeof options === "number" ) {
2399			duration = options;
2400		}
2401		if ( typeof options === "string" ) {
2402			easing = options;
2403		}
2404		// fall back from options to animation in case of partial down settings
2405		easing = easing || options.easing || animate.easing;
2406		duration = duration || options.duration || animate.duration;
2407
2408		if ( !toHide.length ) {
2409			return toShow.animate( this.showProps, duration, easing, complete );
2410		}
2411		if ( !toShow.length ) {
2412			return toHide.animate( this.hideProps, duration, easing, complete );
2413		}
2414
2415		total = toShow.show().outerHeight();
2416		toHide.animate( this.hideProps, {
2417			duration: duration,
2418			easing: easing,
2419			step: function( now, fx ) {
2420				fx.now = Math.round( now );
2421			}
2422		});
2423		toShow
2424			.hide()
2425			.animate( this.showProps, {
2426				duration: duration,
2427				easing: easing,
2428				complete: complete,
2429				step: function( now, fx ) {
2430					fx.now = Math.round( now );
2431					if ( fx.prop !== "height" ) {
2432						adjust += fx.now;
2433					} else if ( that.options.heightStyle !== "content" ) {
2434						fx.now = Math.round( total - toHide.outerHeight() - adjust );
2435						adjust = 0;
2436					}
2437				}
2438			});
2439	},
2440
2441	_toggleComplete: function( data ) {
2442		var toHide = data.oldPanel;
2443
2444		toHide
2445			.removeClass( "ui-accordion-content-active" )
2446			.prev()
2447				.removeClass( "ui-corner-top" )
2448				.addClass( "ui-corner-all" );
2449
2450		// Work around for rendering bug in IE (#5421)
2451		if ( toHide.length ) {
2452			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2453		}
2454		this._trigger( "activate", null, data );
2455	}
2456});
2457
2458
2459/*!
2460 * jQuery UI Menu 1.11.1
2461 * http://jqueryui.com
2462 *
2463 * Copyright 2014 jQuery Foundation and other contributors
2464 * Released under the MIT license.
2465 * http://jquery.org/license
2466 *
2467 * http://api.jqueryui.com/menu/
2468 */
2469
2470
2471var menu = $.widget( "ui.menu", {
2472	version: "1.11.1",
2473	defaultElement: "<ul>",
2474	delay: 300,
2475	options: {
2476		icons: {
2477			submenu: "ui-icon-carat-1-e"
2478		},
2479		items: "> *",
2480		menus: "ul",
2481		position: {
2482			my: "left-1 top",
2483			at: "right top"
2484		},
2485		role: "menu",
2486
2487		// callbacks
2488		blur: null,
2489		focus: null,
2490		select: null
2491	},
2492
2493	_create: function() {
2494		this.activeMenu = this.element;
2495
2496		// Flag used to prevent firing of the click handler
2497		// as the event bubbles up through nested menus
2498		this.mouseHandled = false;
2499		this.element
2500			.uniqueId()
2501			.addClass( "ui-menu ui-widget ui-widget-content" )
2502			.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2503			.attr({
2504				role: this.options.role,
2505				tabIndex: 0
2506			});
2507
2508		if ( this.options.disabled ) {
2509			this.element
2510				.addClass( "ui-state-disabled" )
2511				.attr( "aria-disabled", "true" );
2512		}
2513
2514		this._on({
2515			// Prevent focus from sticking to links inside menu after clicking
2516			// them (focus should always stay on UL during navigation).
2517			"mousedown .ui-menu-item": function( event ) {
2518				event.preventDefault();
2519			},
2520			"click .ui-menu-item": function( event ) {
2521				var target = $( event.target );
2522				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2523					this.select( event );
2524
2525					// Only set the mouseHandled flag if the event will bubble, see #9469.
2526					if ( !event.isPropagationStopped() ) {
2527						this.mouseHandled = true;
2528					}
2529
2530					// Open submenu on click
2531					if ( target.has( ".ui-menu" ).length ) {
2532						this.expand( event );
2533					} else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2534
2535						// Redirect focus to the menu
2536						this.element.trigger( "focus", [ true ] );
2537
2538						// If the active item is on the top level, let it stay active.
2539						// Otherwise, blur the active item since it is no longer visible.
2540						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2541							clearTimeout( this.timer );
2542						}
2543					}
2544				}
2545			},
2546			"mouseenter .ui-menu-item": function( event ) {
2547				var target = $( event.currentTarget );
2548				// Remove ui-state-active class from siblings of the newly focused menu item
2549				// to avoid a jump caused by adjacent elements both having a class with a border
2550				target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2551				this.focus( event, target );
2552			},
2553			mouseleave: "collapseAll",
2554			"mouseleave .ui-menu": "collapseAll",
2555			focus: function( event, keepActiveItem ) {
2556				// If there's already an active item, keep it active
2557				// If not, activate the first item
2558				var item = this.active || this.element.find( this.options.items ).eq( 0 );
2559
2560				if ( !keepActiveItem ) {
2561					this.focus( event, item );
2562				}
2563			},
2564			blur: function( event ) {
2565				this._delay(function() {
2566					if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2567						this.collapseAll( event );
2568					}
2569				});
2570			},
2571			keydown: "_keydown"
2572		});
2573
2574		this.refresh();
2575
2576		// Clicks outside of a menu collapse any open menus
2577		this._on( this.document, {
2578			click: function( event ) {
2579				if ( this._closeOnDocumentClick( event ) ) {
2580					this.collapseAll( event );
2581				}
2582
2583				// Reset the mouseHandled flag
2584				this.mouseHandled = false;
2585			}
2586		});
2587	},
2588
2589	_destroy: function() {
2590		// Destroy (sub)menus
2591		this.element
2592			.removeAttr( "aria-activedescendant" )
2593			.find( ".ui-menu" ).addBack()
2594				.removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2595				.removeAttr( "role" )
2596				.removeAttr( "tabIndex" )
2597				.removeAttr( "aria-labelledby" )
2598				.removeAttr( "aria-expanded" )
2599				.removeAttr( "aria-hidden" )
2600				.removeAttr( "aria-disabled" )
2601				.removeUniqueId()
2602				.show();
2603
2604		// Destroy menu items
2605		this.element.find( ".ui-menu-item" )
2606			.removeClass( "ui-menu-item" )
2607			.removeAttr( "role" )
2608			.removeAttr( "aria-disabled" )
2609			.removeUniqueId()
2610			.removeClass( "ui-state-hover" )
2611			.removeAttr( "tabIndex" )
2612			.removeAttr( "role" )
2613			.removeAttr( "aria-haspopup" )
2614			.children().each( function() {
2615				var elem = $( this );
2616				if ( elem.data( "ui-menu-submenu-carat" ) ) {
2617					elem.remove();
2618				}
2619			});
2620
2621		// Destroy menu dividers
2622		this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2623	},
2624
2625	_keydown: function( event ) {
2626		var match, prev, character, skip, regex,
2627			preventDefault = true;
2628
2629		function escape( value ) {
2630			return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
2631		}
2632
2633		switch ( event.keyCode ) {
2634		case $.ui.keyCode.PAGE_UP:
2635			this.previousPage( event );
2636			break;
2637		case $.ui.keyCode.PAGE_DOWN:
2638			this.nextPage( event );
2639			break;
2640		case $.ui.keyCode.HOME:
2641			this._move( "first", "first", event );
2642			break;
2643		case $.ui.keyCode.END:
2644			this._move( "last", "last", event );
2645			break;
2646		case $.ui.keyCode.UP:
2647			this.previous( event );
2648			break;
2649		case $.ui.keyCode.DOWN:
2650			this.next( event );
2651			break;
2652		case $.ui.keyCode.LEFT:
2653			this.collapse( event );
2654			break;
2655		case $.ui.keyCode.RIGHT:
2656			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2657				this.expand( event );
2658			}
2659			break;
2660		case $.ui.keyCode.ENTER:
2661		case $.ui.keyCode.SPACE:
2662			this._activate( event );
2663			break;
2664		case $.ui.keyCode.ESCAPE:
2665			this.collapse( event );
2666			break;
2667		default:
2668			preventDefault = false;
2669			prev = this.previousFilter || "";
2670			character = String.fromCharCode( event.keyCode );
2671			skip = false;
2672
2673			clearTimeout( this.filterTimer );
2674
2675			if ( character === prev ) {
2676				skip = true;
2677			} else {
2678				character = prev + character;
2679			}
2680
2681			regex = new RegExp( "^" + escape( character ), "i" );
2682			match = this.activeMenu.find( this.options.items ).filter(function() {
2683				return regex.test( $( this ).text() );
2684			});
2685			match = skip && match.index( this.active.next() ) !== -1 ?
2686				this.active.nextAll( ".ui-menu-item" ) :
2687				match;
2688
2689			// If no matches on the current filter, reset to the last character pressed
2690			// to move down the menu to the first item that starts with that character
2691			if ( !match.length ) {
2692				character = String.fromCharCode( event.keyCode );
2693				regex = new RegExp( "^" + escape( character ), "i" );
2694				match = this.activeMenu.find( this.options.items ).filter(function() {
2695					return regex.test( $( this ).text() );
2696				});
2697			}
2698
2699			if ( match.length ) {
2700				this.focus( event, match );
2701				if ( match.length > 1 ) {
2702					this.previousFilter = character;
2703					this.filterTimer = this._delay(function() {
2704						delete this.previousFilter;
2705					}, 1000 );
2706				} else {
2707					delete this.previousFilter;
2708				}
2709			} else {
2710				delete this.previousFilter;
2711			}
2712		}
2713
2714		if ( preventDefault ) {
2715			event.preventDefault();
2716		}
2717	},
2718
2719	_activate: function( event ) {
2720		if ( !this.active.is( ".ui-state-disabled" ) ) {
2721			if ( this.active.is( "[aria-haspopup='true']" ) ) {
2722				this.expand( event );
2723			} else {
2724				this.select( event );
2725			}
2726		}
2727	},
2728
2729	refresh: function() {
2730		var menus, items,
2731			that = this,
2732			icon = this.options.icons.submenu,
2733			submenus = this.element.find( this.options.menus );
2734
2735		this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2736
2737		// Initialize nested menus
2738		submenus.filter( ":not(.ui-menu)" )
2739			.addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2740			.hide()
2741			.attr({
2742				role: this.options.role,
2743				"aria-hidden": "true",
2744				"aria-expanded": "false"
2745			})
2746			.each(function() {
2747				var menu = $( this ),
2748					item = menu.parent(),
2749					submenuCarat = $( "<span>" )
2750						.addClass( "ui-menu-icon ui-icon " + icon )
2751						.data( "ui-menu-submenu-carat", true );
2752
2753				item
2754					.attr( "aria-haspopup", "true" )
2755					.prepend( submenuCarat );
2756				menu.attr( "aria-labelledby", item.attr( "id" ) );
2757			});
2758
2759		menus = submenus.add( this.element );
2760		items = menus.find( this.options.items );
2761
2762		// Initialize menu-items containing spaces and/or dashes only as dividers
2763		items.not( ".ui-menu-item" ).each(function() {
2764			var item = $( this );
2765			if ( that._isDivider( item ) ) {
2766				item.addClass( "ui-widget-content ui-menu-divider" );
2767			}
2768		});
2769
2770		// Don't refresh list items that are already adapted
2771		items.not( ".ui-menu-item, .ui-menu-divider" )
2772			.addClass( "ui-menu-item" )
2773			.uniqueId()
2774			.attr({
2775				tabIndex: -1,
2776				role: this._itemRole()
2777			});
2778
2779		// Add aria-disabled attribute to any disabled menu item
2780		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2781
2782		// If the active item has been removed, blur the menu
2783		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2784			this.blur();
2785		}
2786	},
2787
2788	_itemRole: function() {
2789		return {
2790			menu: "menuitem",
2791			listbox: "option"
2792		}[ this.options.role ];
2793	},
2794
2795	_setOption: function( key, value ) {
2796		if ( key === "icons" ) {
2797			this.element.find( ".ui-menu-icon" )
2798				.removeClass( this.options.icons.submenu )
2799				.addClass( value.submenu );
2800		}
2801		if ( key === "disabled" ) {
2802			this.element
2803				.toggleClass( "ui-state-disabled", !!value )
2804				.attr( "aria-disabled", value );
2805		}
2806		this._super( key, value );
2807	},
2808
2809	focus: function( event, item ) {
2810		var nested, focused;
2811		this.blur( event, event && event.type === "focus" );
2812
2813		this._scrollIntoView( item );
2814
2815		this.active = item.first();
2816		focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2817		// Only update aria-activedescendant if there's a role
2818		// otherwise we assume focus is managed elsewhere
2819		if ( this.options.role ) {
2820			this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2821		}
2822
2823		// Highlight active parent menu item, if any
2824		this.active
2825			.parent()
2826			.closest( ".ui-menu-item" )
2827			.addClass( "ui-state-active" );
2828
2829		if ( event && event.type === "keydown" ) {
2830			this._close();
2831		} else {
2832			this.timer = this._delay(function() {
2833				this._close();
2834			}, this.delay );
2835		}
2836
2837		nested = item.children( ".ui-menu" );
2838		if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2839			this._startOpening(nested);
2840		}
2841		this.activeMenu = item.parent();
2842
2843		this._trigger( "focus", event, { item: item } );
2844	},
2845
2846	_scrollIntoView: function( item ) {
2847		var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2848		if ( this._hasScroll() ) {
2849			borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2850			paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2851			offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2852			scroll = this.activeMenu.scrollTop();
2853			elementHeight = this.activeMenu.height();
2854			itemHeight = item.outerHeight();
2855
2856			if ( offset < 0 ) {
2857				this.activeMenu.scrollTop( scroll + offset );
2858			} else if ( offset + itemHeight > elementHeight ) {
2859				this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2860			}
2861		}
2862	},
2863
2864	blur: function( event, fromFocus ) {
2865		if ( !fromFocus ) {
2866			clearTimeout( this.timer );
2867		}
2868
2869		if ( !this.active ) {
2870			return;
2871		}
2872
2873		this.active.removeClass( "ui-state-focus" );
2874		this.active = null;
2875
2876		this._trigger( "blur", event, { item: this.active } );
2877	},
2878
2879	_startOpening: function( submenu ) {
2880		clearTimeout( this.timer );
2881
2882		// Don't open if already open fixes a Firefox bug that caused a .5 pixel
2883		// shift in the submenu position when mousing over the carat icon
2884		if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2885			return;
2886		}
2887
2888		this.timer = this._delay(function() {
2889			this._close();
2890			this._open( submenu );
2891		}, this.delay );
2892	},
2893
2894	_open: function( submenu ) {
2895		var position = $.extend({
2896			of: this.active
2897		}, this.options.position );
2898
2899		clearTimeout( this.timer );
2900		this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2901			.hide()
2902			.attr( "aria-hidden", "true" );
2903
2904		submenu
2905			.show()
2906			.removeAttr( "aria-hidden" )
2907			.attr( "aria-expanded", "true" )
2908			.position( position );
2909	},
2910
2911	collapseAll: function( event, all ) {
2912		clearTimeout( this.timer );
2913		this.timer = this._delay(function() {
2914			// If we were passed an event, look for the submenu that contains the event
2915			var currentMenu = all ? this.element :
2916				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2917
2918			// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2919			if ( !currentMenu.length ) {
2920				currentMenu = this.element;
2921			}
2922
2923			this._close( currentMenu );
2924
2925			this.blur( event );
2926			this.activeMenu = currentMenu;
2927		}, this.delay );
2928	},
2929
2930	// With no arguments, closes the currently active menu - if nothing is active
2931	// it closes all menus.  If passed an argument, it will search for menus BELOW
2932	_close: function( startMenu ) {
2933		if ( !startMenu ) {
2934			startMenu = this.active ? this.active.parent() : this.element;
2935		}
2936
2937		startMenu
2938			.find( ".ui-menu" )
2939				.hide()
2940				.attr( "aria-hidden", "true" )
2941				.attr( "aria-expanded", "false" )
2942			.end()
2943			.find( ".ui-state-active" ).not( ".ui-state-focus" )
2944				.removeClass( "ui-state-active" );
2945	},
2946
2947	_closeOnDocumentClick: function( event ) {
2948		return !$( event.target ).closest( ".ui-menu" ).length;
2949	},
2950
2951	_isDivider: function( item ) {
2952
2953		// Match hyphen, em dash, en dash
2954		return !/[^\-\u2014\u2013\s]/.test( item.text() );
2955	},
2956
2957	collapse: function( event ) {
2958		var newItem = this.active &&
2959			this.active.parent().closest( ".ui-menu-item", this.element );
2960		if ( newItem && newItem.length ) {
2961			this._close();
2962			this.focus( event, newItem );
2963		}
2964	},
2965
2966	expand: function( event ) {
2967		var newItem = this.active &&
2968			this.active
2969				.children( ".ui-menu " )
2970				.find( this.options.items )
2971				.first();
2972
2973		if ( newItem && newItem.length ) {
2974			this._open( newItem.parent() );
2975
2976			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2977			this._delay(function() {
2978				this.focus( event, newItem );
2979			});
2980		}
2981	},
2982
2983	next: function( event ) {
2984		this._move( "next", "first", event );
2985	},
2986
2987	previous: function( event ) {
2988		this._move( "prev", "last", event );
2989	},
2990
2991	isFirstItem: function() {
2992		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2993	},
2994
2995	isLastItem: function() {
2996		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2997	},
2998
2999	_move: function( direction, filter, event ) {
3000		var next;
3001		if ( this.active ) {
3002			if ( direction === "first" || direction === "last" ) {
3003				next = this.active
3004					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
3005					.eq( -1 );
3006			} else {
3007				next = this.active
3008					[ direction + "All" ]( ".ui-menu-item" )
3009					.eq( 0 );
3010			}
3011		}
3012		if ( !next || !next.length || !this.active ) {
3013			next = this.activeMenu.find( this.options.items )[ filter ]();
3014		}
3015
3016		this.focus( event, next );
3017	},
3018
3019	nextPage: function( event ) {
3020		var item, base, height;
3021
3022		if ( !this.active ) {
3023			this.next( event );
3024			return;
3025		}
3026		if ( this.isLastItem() ) {
3027			return;
3028		}
3029		if ( this._hasScroll() ) {
3030			base = this.active.offset().top;
3031			height = this.element.height();
3032			this.active.nextAll( ".ui-menu-item" ).each(function() {
3033				item = $( this );
3034				return item.offset().top - base - height < 0;
3035			});
3036
3037			this.focus( event, item );
3038		} else {
3039			this.focus( event, this.activeMenu.find( this.options.items )
3040				[ !this.active ? "first" : "last" ]() );
3041		}
3042	},
3043
3044	previousPage: function( event ) {
3045		var item, base, height;
3046		if ( !this.active ) {
3047			this.next( event );
3048			return;
3049		}
3050		if ( this.isFirstItem() ) {
3051			return;
3052		}
3053		if ( this._hasScroll() ) {
3054			base = this.active.offset().top;
3055			height = this.element.height();
3056			this.active.prevAll( ".ui-menu-item" ).each(function() {
3057				item = $( this );
3058				return item.offset().top - base + height > 0;
3059			});
3060
3061			this.focus( event, item );
3062		} else {
3063			this.focus( event, this.activeMenu.find( this.options.items ).first() );
3064		}
3065	},
3066
3067	_hasScroll: function() {
3068		return this.element.outerHeight() < this.element.prop( "scrollHeight" );
3069	},
3070
3071	select: function( event ) {
3072		// TODO: It should never be possible to not have an active item at this
3073		// point, but the tests don't trigger mouseenter before click.
3074		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
3075		var ui = { item: this.active };
3076		if ( !this.active.has( ".ui-menu" ).length ) {
3077			this.collapseAll( event, true );
3078		}
3079		this._trigger( "select", event, ui );
3080	}
3081});
3082
3083
3084/*!
3085 * jQuery UI Autocomplete 1.11.1
3086 * http://jqueryui.com
3087 *
3088 * Copyright 2014 jQuery Foundation and other contributors
3089 * Released under the MIT license.
3090 * http://jquery.org/license
3091 *
3092 * http://api.jqueryui.com/autocomplete/
3093 */
3094
3095
3096$.widget( "ui.autocomplete", {
3097	version: "1.11.1",
3098	defaultElement: "<input>",
3099	options: {
3100		appendTo: null,
3101		autoFocus: false,
3102		delay: 300,
3103		minLength: 1,
3104		position: {
3105			my: "left top",
3106			at: "left bottom",
3107			collision: "none"
3108		},
3109		source: null,
3110
3111		// callbacks
3112		change: null,
3113		close: null,
3114		focus: null,
3115		open: null,
3116		response: null,
3117		search: null,
3118		select: null
3119	},
3120
3121	requestIndex: 0,
3122	pending: 0,
3123
3124	_create: function() {
3125		// Some browsers only repeat keydown events, not keypress events,
3126		// so we use the suppressKeyPress flag to determine if we've already
3127		// handled the keydown event. #7269
3128		// Unfortunately the code for & in keypress is the same as the up arrow,
3129		// so we use the suppressKeyPressRepeat flag to avoid handling keypress
3130		// events when we know the keydown event was used to modify the
3131		// search term. #7799
3132		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
3133			nodeName = this.element[ 0 ].nodeName.toLowerCase(),
3134			isTextarea = nodeName === "textarea",
3135			isInput = nodeName === "input";
3136
3137		this.isMultiLine =
3138			// Textareas are always multi-line
3139			isTextarea ? true :
3140			// Inputs are always single-line, even if inside a contentEditable element
3141			// IE also treats inputs as contentEditable
3142			isInput ? false :
3143			// All other element types are determined by whether or not they're contentEditable
3144			this.element.prop( "isContentEditable" );
3145
3146		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
3147		this.isNewMenu = true;
3148
3149		this.element
3150			.addClass( "ui-autocomplete-input" )
3151			.attr( "autocomplete", "off" );
3152
3153		this._on( this.element, {
3154			keydown: function( event ) {
3155				if ( this.element.prop( "readOnly" ) ) {
3156					suppressKeyPress = true;
3157					suppressInput = true;
3158					suppressKeyPressRepeat = true;
3159					return;
3160				}
3161
3162				suppressKeyPress = false;
3163				suppressInput = false;
3164				suppressKeyPressRepeat = false;
3165				var keyCode = $.ui.keyCode;
3166				switch ( event.keyCode ) {
3167				case keyCode.PAGE_UP:
3168					suppressKeyPress = true;
3169					this._move( "previousPage", event );
3170					break;
3171				case keyCode.PAGE_DOWN:
3172					suppressKeyPress = true;
3173					this._move( "nextPage", event );
3174					break;
3175				case keyCode.UP:
3176					suppressKeyPress = true;
3177					this._keyEvent( "previous", event );
3178					break;
3179				case keyCode.DOWN:
3180					suppressKeyPress = true;
3181					this._keyEvent( "next", event );
3182					break;
3183				case keyCode.ENTER:
3184					// when menu is open and has focus
3185					if ( this.menu.active ) {
3186						// #6055 - Opera still allows the keypress to occur
3187						// which causes forms to submit
3188						suppressKeyPress = true;
3189						event.preventDefault();
3190						this.menu.select( event );
3191					}
3192					break;
3193				case keyCode.TAB:
3194					if ( this.menu.active ) {
3195						this.menu.select( event );
3196					}
3197					break;
3198				case keyCode.ESCAPE:
3199					if ( this.menu.element.is( ":visible" ) ) {
3200						if ( !this.isMultiLine ) {
3201							this._value( this.term );
3202						}
3203						this.close( event );
3204						// Different browsers have different default behavior for escape
3205						// Single press can mean undo or clear
3206						// Double press in IE means clear the whole form
3207						event.preventDefault();
3208					}
3209					break;
3210				default:
3211					suppressKeyPressRepeat = true;
3212					// search timeout should be triggered before the input value is changed
3213					this._searchTimeout( event );
3214					break;
3215				}
3216			},
3217			keypress: function( event ) {
3218				if ( suppressKeyPress ) {
3219					suppressKeyPress = false;
3220					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3221						event.preventDefault();
3222					}
3223					return;
3224				}
3225				if ( suppressKeyPressRepeat ) {
3226					return;
3227				}
3228
3229				// replicate some key handlers to allow them to repeat in Firefox and Opera
3230				var keyCode = $.ui.keyCode;
3231				switch ( event.keyCode ) {
3232				case keyCode.PAGE_UP:
3233					this._move( "previousPage", event );
3234					break;
3235				case keyCode.PAGE_DOWN:
3236					this._move( "nextPage", event );
3237					break;
3238				case keyCode.UP:
3239					this._keyEvent( "previous", event );
3240					break;
3241				case keyCode.DOWN:
3242					this._keyEvent( "next", event );
3243					break;
3244				}
3245			},
3246			input: function( event ) {
3247				if ( suppressInput ) {
3248					suppressInput = false;
3249					event.preventDefault();
3250					return;
3251				}
3252				this._searchTimeout( event );
3253			},
3254			focus: function() {
3255				this.selectedItem = null;
3256				this.previous = this._value();
3257			},
3258			blur: function( event ) {
3259				if ( this.cancelBlur ) {
3260					delete this.cancelBlur;
3261					return;
3262				}
3263
3264				clearTimeout( this.searching );
3265				this.close( event );
3266				this._change( event );
3267			}
3268		});
3269
3270		this._initSource();
3271		this.menu = $( "<ul>" )
3272			.addClass( "ui-autocomplete ui-front" )
3273			.appendTo( this._appendTo() )
3274			.menu({
3275				// disable ARIA support, the live region takes care of that
3276				role: null
3277			})
3278			.hide()
3279			.menu( "instance" );
3280
3281		this._on( this.menu.element, {
3282			mousedown: function( event ) {
3283				// prevent moving focus out of the text field
3284				event.preventDefault();
3285
3286				// IE doesn't prevent moving focus even with event.preventDefault()
3287				// so we set a flag to know when we should ignore the blur event
3288				this.cancelBlur = true;
3289				this._delay(function() {
3290					delete this.cancelBlur;
3291				});
3292
3293				// clicking on the scrollbar causes focus to shift to the body
3294				// but we can't detect a mouseup or a click immediately afterward
3295				// so we have to track the next mousedown and close the menu if
3296				// the user clicks somewhere outside of the autocomplete
3297				var menuElement = this.menu.element[ 0 ];
3298				if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
3299					this._delay(function() {
3300						var that = this;
3301						this.document.one( "mousedown", function( event ) {
3302							if ( event.target !== that.element[ 0 ] &&
3303									event.target !== menuElement &&
3304									!$.contains( menuElement, event.target ) ) {
3305								that.close();
3306							}
3307						});
3308					});
3309				}
3310			},
3311			menufocus: function( event, ui ) {
3312				var label, item;
3313				// support: Firefox
3314				// Prevent accidental activation of menu items in Firefox (#7024 #9118)
3315				if ( this.isNewMenu ) {
3316					this.isNewMenu = false;
3317					if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
3318						this.menu.blur();
3319
3320						this.document.one( "mousemove", function() {
3321							$( event.target ).trigger( event.originalEvent );
3322						});
3323
3324						return;
3325					}
3326				}
3327
3328				item = ui.item.data( "ui-autocomplete-item" );
3329				if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3330					// use value to match what will end up in the input, if it was a key event
3331					if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3332						this._value( item.value );
3333					}
3334				}
3335
3336				// Announce the value in the liveRegion
3337				label = ui.item.attr( "aria-label" ) || item.value;
3338				if ( label && $.trim( label ).length ) {
3339					this.liveRegion.children().hide();
3340					$( "<div>" ).text( label ).appendTo( this.liveRegion );
3341				}
3342			},
3343			menuselect: function( event, ui ) {
3344				var item = ui.item.data( "ui-autocomplete-item" ),
3345					previous = this.previous;
3346
3347				// only trigger when focus was lost (click on menu)
3348				if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
3349					this.element.focus();
3350					this.previous = previous;
3351					// #6109 - IE triggers two focus events and the second
3352					// is asynchronous, so we need to reset the previous
3353					// term synchronously and asynchronously :-(
3354					this._delay(function() {
3355						this.previous = previous;
3356						this.selectedItem = item;
3357					});
3358				}
3359
3360				if ( false !== this._trigger( "select", event, { item: item } ) ) {
3361					this._value( item.value );
3362				}
3363				// reset the term after the select event
3364				// this allows custom select handling to work properly
3365				this.term = this._value();
3366
3367				this.close( event );
3368				this.selectedItem = item;
3369			}
3370		});
3371
3372		this.liveRegion = $( "<span>", {
3373				role: "status",
3374				"aria-live": "assertive",
3375				"aria-relevant": "additions"
3376			})
3377			.addClass( "ui-helper-hidden-accessible" )
3378			.appendTo( this.document[ 0 ].body );
3379
3380		// turning off autocomplete prevents the browser from remembering the
3381		// value when navigating through history, so we re-enable autocomplete
3382		// if the page is unloaded before the widget is destroyed. #7790
3383		this._on( this.window, {
3384			beforeunload: function() {
3385				this.element.removeAttr( "autocomplete" );
3386			}
3387		});
3388	},
3389
3390	_destroy: function() {
3391		clearTimeout( this.searching );
3392		this.element
3393			.removeClass( "ui-autocomplete-input" )
3394			.removeAttr( "autocomplete" );
3395		this.menu.element.remove();
3396		this.liveRegion.remove();
3397	},
3398
3399	_setOption: function( key, value ) {
3400		this._super( key, value );
3401		if ( key === "source" ) {
3402			this._initSource();
3403		}
3404		if ( key === "appendTo" ) {
3405			this.menu.element.appendTo( this._appendTo() );
3406		}
3407		if ( key === "disabled" && value && this.xhr ) {
3408			this.xhr.abort();
3409		}
3410	},
3411
3412	_appendTo: function() {
3413		var element = this.options.appendTo;
3414
3415		if ( element ) {
3416			element = element.jquery || element.nodeType ?
3417				$( element ) :
3418				this.document.find( element ).eq( 0 );
3419		}
3420
3421		if ( !element || !element[ 0 ] ) {
3422			element = this.element.closest( ".ui-front" );
3423		}
3424
3425		if ( !element.length ) {
3426			element = this.document[ 0 ].body;
3427		}
3428
3429		return element;
3430	},
3431
3432	_initSource: function() {
3433		var array, url,
3434			that = this;
3435		if ( $.isArray( this.options.source ) ) {
3436			array = this.options.source;
3437			this.source = function( request, response ) {
3438				response( $.ui.autocomplete.filter( array, request.term ) );
3439			};
3440		} else if ( typeof this.options.source === "string" ) {
3441			url = this.options.source;
3442			this.source = function( request, response ) {
3443				if ( that.xhr ) {
3444					that.xhr.abort();
3445				}
3446				that.xhr = $.ajax({
3447					url: url,
3448					data: request,
3449					dataType: "json",
3450					success: function( data ) {
3451						response( data );
3452					},
3453					error: function() {
3454						response([]);
3455					}
3456				});
3457			};
3458		} else {
3459			this.source = this.options.source;
3460		}
3461	},
3462
3463	_searchTimeout: function( event ) {
3464		clearTimeout( this.searching );
3465		this.searching = this._delay(function() {
3466
3467			// Search if the value has changed, or if the user retypes the same value (see #7434)
3468			var equalValues = this.term === this._value(),
3469				menuVisible = this.menu.element.is( ":visible" ),
3470				modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
3471
3472			if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
3473				this.selectedItem = null;
3474				this.search( null, event );
3475			}
3476		}, this.options.delay );
3477	},
3478
3479	search: function( value, event ) {
3480		value = value != null ? value : this._value();
3481
3482		// always save the actual value, not the one passed as an argument
3483		this.term = this._value();
3484
3485		if ( value.length < this.options.minLength ) {
3486			return this.close( event );
3487		}
3488
3489		if ( this._trigger( "search", event ) === false ) {
3490			return;
3491		}
3492
3493		return this._search( value );
3494	},
3495
3496	_search: function( value ) {
3497		this.pending++;
3498		this.element.addClass( "ui-autocomplete-loading" );
3499		this.cancelSearch = false;
3500
3501		this.source( { term: value }, this._response() );
3502	},
3503
3504	_response: function() {
3505		var index = ++this.requestIndex;
3506
3507		return $.proxy(function( content ) {
3508			if ( index === this.requestIndex ) {
3509				this.__response( content );
3510			}
3511
3512			this.pending--;
3513			if ( !this.pending ) {
3514				this.element.removeClass( "ui-autocomplete-loading" );
3515			}
3516		}, this );
3517	},
3518
3519	__response: function( content ) {
3520		if ( content ) {
3521			content = this._normalize( content );
3522		}
3523		this._trigger( "response", null, { content: content } );
3524		if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3525			this._suggest( content );
3526			this._trigger( "open" );
3527		} else {
3528			// use ._close() instead of .close() so we don't cancel future searches
3529			this._close();
3530		}
3531	},
3532
3533	close: function( event ) {
3534		this.cancelSearch = true;
3535		this._close( event );
3536	},
3537
3538	_close: function( event ) {
3539		if ( this.menu.element.is( ":visible" ) ) {
3540			this.menu.element.hide();
3541			this.menu.blur();
3542			this.isNewMenu = true;
3543			this._trigger( "close", event );
3544		}
3545	},
3546
3547	_change: function( event ) {
3548		if ( this.previous !== this._value() ) {
3549			this._trigger( "change", event, { item: this.selectedItem } );
3550		}
3551	},
3552
3553	_normalize: function( items ) {
3554		// assume all items have the right format when the first item is complete
3555		if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
3556			return items;
3557		}
3558		return $.map( items, function( item ) {
3559			if ( typeof item === "string" ) {
3560				return {
3561					label: item,
3562					value: item
3563				};
3564			}
3565			return $.extend( {}, item, {
3566				label: item.label || item.value,
3567				value: item.value || item.label
3568			});
3569		});
3570	},
3571
3572	_suggest: function( items ) {
3573		var ul = this.menu.element.empty();
3574		this._renderMenu( ul, items );
3575		this.isNewMenu = true;
3576		this.menu.refresh();
3577
3578		// size and position menu
3579		ul.show();
3580		this._resizeMenu();
3581		ul.position( $.extend({
3582			of: this.element
3583		}, this.options.position ) );
3584
3585		if ( this.options.autoFocus ) {
3586			this.menu.next();
3587		}
3588	},
3589
3590	_resizeMenu: function() {
3591		var ul = this.menu.element;
3592		ul.outerWidth( Math.max(
3593			// Firefox wraps long text (possibly a rounding bug)
3594			// so we add 1px to avoid the wrapping (#7513)
3595			ul.width( "" ).outerWidth() + 1,
3596			this.element.outerWidth()
3597		) );
3598	},
3599
3600	_renderMenu: function( ul, items ) {
3601		var that = this;
3602		$.each( items, function( index, item ) {
3603			that._renderItemData( ul, item );
3604		});
3605	},
3606
3607	_renderItemData: function( ul, item ) {
3608		return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3609	},
3610
3611	_renderItem: function( ul, item ) {
3612		return $( "<li>" ).text( item.label ).appendTo( ul );
3613	},
3614
3615	_move: function( direction, event ) {
3616		if ( !this.menu.element.is( ":visible" ) ) {
3617			this.search( null, event );
3618			return;
3619		}
3620		if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3621				this.menu.isLastItem() && /^next/.test( direction ) ) {
3622
3623			if ( !this.isMultiLine ) {
3624				this._value( this.term );
3625			}
3626
3627			this.menu.blur();
3628			return;
3629		}
3630		this.menu[ direction ]( event );
3631	},
3632
3633	widget: function() {
3634		return this.menu.element;
3635	},
3636
3637	_value: function() {
3638		return this.valueMethod.apply( this.element, arguments );
3639	},
3640
3641	_keyEvent: function( keyEvent, event ) {
3642		if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3643			this._move( keyEvent, event );
3644
3645			// prevents moving cursor to beginning/end of the text field in some browsers
3646			event.preventDefault();
3647		}
3648	}
3649});
3650
3651$.extend( $.ui.autocomplete, {
3652	escapeRegex: function( value ) {
3653		return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
3654	},
3655	filter: function( array, term ) {
3656		var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
3657		return $.grep( array, function( value ) {
3658			return matcher.test( value.label || value.value || value );
3659		});
3660	}
3661});
3662
3663// live region extension, adding a `messages` option
3664// NOTE: This is an experimental API. We are still investigating
3665// a full solution for string manipulation and internationalization.
3666$.widget( "ui.autocomplete", $.ui.autocomplete, {
3667	options: {
3668		messages: {
3669			noResults: "No search results.",
3670			results: function( amount ) {
3671				return amount + ( amount > 1 ? " results are" : " result is" ) +
3672					" available, use up and down arrow keys to navigate.";
3673			}
3674		}
3675	},
3676
3677	__response: function( content ) {
3678		var message;
3679		this._superApply( arguments );
3680		if ( this.options.disabled || this.cancelSearch ) {
3681			return;
3682		}
3683		if ( content && content.length ) {
3684			message = this.options.messages.results( content.length );
3685		} else {
3686			message = this.options.messages.noResults;
3687		}
3688		this.liveRegion.children().hide();
3689		$( "<div>" ).text( message ).appendTo( this.liveRegion );
3690	}
3691});
3692
3693var autocomplete = $.ui.autocomplete;
3694
3695
3696/*!
3697 * jQuery UI Button 1.11.1
3698 * http://jqueryui.com
3699 *
3700 * Copyright 2014 jQuery Foundation and other contributors
3701 * Released under the MIT license.
3702 * http://jquery.org/license
3703 *
3704 * http://api.jqueryui.com/button/
3705 */
3706
3707
3708var lastActive,
3709	baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3710	typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
3711	formResetHandler = function() {
3712		var form = $( this );
3713		setTimeout(function() {
3714			form.find( ":ui-button" ).button( "refresh" );
3715		}, 1 );
3716	},
3717	radioGroup = function( radio ) {
3718		var name = radio.name,
3719			form = radio.form,
3720			radios = $( [] );
3721		if ( name ) {
3722			name = name.replace( /'/g, "\\'" );
3723			if ( form ) {
3724				radios = $( form ).find( "[name='" + name + "'][type=radio]" );
3725			} else {
3726				radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
3727					.filter(function() {
3728						return !this.form;
3729					});
3730			}
3731		}
3732		return radios;
3733	};
3734
3735$.widget( "ui.button", {
3736	version: "1.11.1",
3737	defaultElement: "<button>",
3738	options: {
3739		disabled: null,
3740		text: true,
3741		label: null,
3742		icons: {
3743			primary: null,
3744			secondary: null
3745		}
3746	},
3747	_create: function() {
3748		this.element.closest( "form" )
3749			.unbind( "reset" + this.eventNamespace )
3750			.bind( "reset" + this.eventNamespace, formResetHandler );
3751
3752		if ( typeof this.options.disabled !== "boolean" ) {
3753			this.options.disabled = !!this.element.prop( "disabled" );
3754		} else {
3755			this.element.prop( "disabled", this.options.disabled );
3756		}
3757
3758		this._determineButtonType();
3759		this.hasTitle = !!this.buttonElement.attr( "title" );
3760
3761		var that = this,
3762			options = this.options,
3763			toggleButton = this.type === "checkbox" || this.type === "radio",
3764			activeClass = !toggleButton ? "ui-state-active" : "";
3765
3766		if ( options.label === null ) {
3767			options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3768		}
3769
3770		this._hoverable( this.buttonElement );
3771
3772		this.buttonElement
3773			.addClass( baseClasses )
3774			.attr( "role", "button" )
3775			.bind( "mouseenter" + this.eventNamespace, function() {
3776				if ( options.disabled ) {
3777					return;
3778				}
3779				if ( this === lastActive ) {
3780					$( this ).addClass( "ui-state-active" );
3781				}
3782			})
3783			.bind( "mouseleave" + this.eventNamespace, function() {
3784				if ( options.disabled ) {
3785					return;
3786				}
3787				$( this ).removeClass( activeClass );
3788			})
3789			.bind( "click" + this.eventNamespace, function( event ) {
3790				if ( options.disabled ) {
3791					event.preventDefault();
3792					event.stopImmediatePropagation();
3793				}
3794			});
3795
3796		// Can't use _focusable() because the element that receives focus
3797		// and the element that gets the ui-state-focus class are different
3798		this._on({
3799			focus: function() {
3800				this.buttonElement.addClass( "ui-state-focus" );
3801			},
3802			blur: function() {
3803				this.buttonElement.removeClass( "ui-state-focus" );
3804			}
3805		});
3806
3807		if ( toggleButton ) {
3808			this.element.bind( "change" + this.eventNamespace, function() {
3809				that.refresh();
3810			});
3811		}
3812
3813		if ( this.type === "checkbox" ) {
3814			this.buttonElement.bind( "click" + this.eventNamespace, function() {
3815				if ( options.disabled ) {
3816					return false;
3817				}
3818			});
3819		} else if ( this.type === "radio" ) {
3820			this.buttonElement.bind( "click" + this.eventNamespace, function() {
3821				if ( options.disabled ) {
3822					return false;
3823				}
3824				$( this ).addClass( "ui-state-active" );
3825				that.buttonElement.attr( "aria-pressed", "true" );
3826
3827				var radio = that.element[ 0 ];
3828				radioGroup( radio )
3829					.not( radio )
3830					.map(function() {
3831						return $( this ).button( "widget" )[ 0 ];
3832					})
3833					.removeClass( "ui-state-active" )
3834					.attr( "aria-pressed", "false" );
3835			});
3836		} else {
3837			this.buttonElement
3838				.bind( "mousedown" + this.eventNamespace, function() {
3839					if ( options.disabled ) {
3840						return false;
3841					}
3842					$( this ).addClass( "ui-state-active" );
3843					lastActive = this;
3844					that.document.one( "mouseup", function() {
3845						lastActive = null;
3846					});
3847				})
3848				.bind( "mouseup" + this.eventNamespace, function() {
3849					if ( options.disabled ) {
3850						return false;
3851					}
3852					$( this ).removeClass( "ui-state-active" );
3853				})
3854				.bind( "keydown" + this.eventNamespace, function(event) {
3855					if ( options.disabled ) {
3856						return false;
3857					}
3858					if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3859						$( this ).addClass( "ui-state-active" );
3860					}
3861				})
3862				// see #8559, we bind to blur here in case the button element loses
3863				// focus between keydown and keyup, it would be left in an "active" state
3864				.bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3865					$( this ).removeClass( "ui-state-active" );
3866				});
3867
3868			if ( this.buttonElement.is("a") ) {
3869				this.buttonElement.keyup(function(event) {
3870					if ( event.keyCode === $.ui.keyCode.SPACE ) {
3871						// TODO pass through original event correctly (just as 2nd argument doesn't work)
3872						$( this ).click();
3873					}
3874				});
3875			}
3876		}
3877
3878		this._setOption( "disabled", options.disabled );
3879		this._resetButton();
3880	},
3881
3882	_determineButtonType: function() {
3883		var ancestor, labelSelector, checked;
3884
3885		if ( this.element.is("[type=checkbox]") ) {
3886			this.type = "checkbox";
3887		} else if ( this.element.is("[type=radio]") ) {
3888			this.type = "radio";
3889		} else if ( this.element.is("input") ) {
3890			this.type = "input";
3891		} else {
3892			this.type = "button";
3893		}
3894
3895		if ( this.type === "checkbox" || this.type === "radio" ) {
3896			// we don't search against the document in case the element
3897			// is disconnected from the DOM
3898			ancestor = this.element.parents().last();
3899			labelSelector = "label[for='" + this.element.attr("id") + "']";
3900			this.buttonElement = ancestor.find( labelSelector );
3901			if ( !this.buttonElement.length ) {
3902				ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
3903				this.buttonElement = ancestor.filter( labelSelector );
3904				if ( !this.buttonElement.length ) {
3905					this.buttonElement = ancestor.find( labelSelector );
3906				}
3907			}
3908			this.element.addClass( "ui-helper-hidden-accessible" );
3909
3910			checked = this.element.is( ":checked" );
3911			if ( checked ) {
3912				this.buttonElement.addClass( "ui-state-active" );
3913			}
3914			this.buttonElement.prop( "aria-pressed", checked );
3915		} else {
3916			this.buttonElement = this.element;
3917		}
3918	},
3919
3920	widget: function() {
3921		return this.buttonElement;
3922	},
3923
3924	_destroy: function() {
3925		this.element
3926			.removeClass( "ui-helper-hidden-accessible" );
3927		this.buttonElement
3928			.removeClass( baseClasses + " ui-state-active " + typeClasses )
3929			.removeAttr( "role" )
3930			.removeAttr( "aria-pressed" )
3931			.html( this.buttonElement.find(".ui-button-text").html() );
3932
3933		if ( !this.hasTitle ) {
3934			this.buttonElement.removeAttr( "title" );
3935		}
3936	},
3937
3938	_setOption: function( key, value ) {
3939		this._super( key, value );
3940		if ( key === "disabled" ) {
3941			this.widget().toggleClass( "ui-state-disabled", !!value );
3942			this.element.prop( "disabled", !!value );
3943			if ( value ) {
3944				if ( this.type === "checkbox" || this.type === "radio" ) {
3945					this.buttonElement.removeClass( "ui-state-focus" );
3946				} else {
3947					this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
3948				}
3949			}
3950			return;
3951		}
3952		this._resetButton();
3953	},
3954
3955	refresh: function() {
3956		//See #8237 & #8828
3957		var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
3958
3959		if ( isDisabled !== this.options.disabled ) {
3960			this._setOption( "disabled", isDisabled );
3961		}
3962		if ( this.type === "radio" ) {
3963			radioGroup( this.element[0] ).each(function() {
3964				if ( $( this ).is( ":checked" ) ) {
3965					$( this ).button( "widget" )
3966						.addClass( "ui-state-active" )
3967						.attr( "aria-pressed", "true" );
3968				} else {
3969					$( this ).button( "widget" )
3970						.removeClass( "ui-state-active" )
3971						.attr( "aria-pressed", "false" );
3972				}
3973			});
3974		} else if ( this.type === "checkbox" ) {
3975			if ( this.element.is( ":checked" ) ) {
3976				this.buttonElement
3977					.addClass( "ui-state-active" )
3978					.attr( "aria-pressed", "true" );
3979			} else {
3980				this.buttonElement
3981					.removeClass( "ui-state-active" )
3982					.attr( "aria-pressed", "false" );
3983			}
3984		}
3985	},
3986
3987	_resetButton: function() {
3988		if ( this.type === "input" ) {
3989			if ( this.options.label ) {
3990				this.element.val( this.options.label );
3991			}
3992			return;
3993		}
3994		var buttonElement = this.buttonElement.removeClass( typeClasses ),
3995			buttonText = $( "<span></span>", this.document[0] )
3996				.addClass( "ui-button-text" )
3997				.html( this.options.label )
3998				.appendTo( buttonElement.empty() )
3999				.text(),
4000			icons = this.options.icons,
4001			multipleIcons = icons.primary && icons.secondary,
4002			buttonClasses = [];
4003
4004		if ( icons.primary || icons.secondary ) {
4005			if ( this.options.text ) {
4006				buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
4007			}
4008
4009			if ( icons.primary ) {
4010				buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
4011			}
4012
4013			if ( icons.secondary ) {
4014				buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
4015			}
4016
4017			if ( !this.options.text ) {
4018				buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
4019
4020				if ( !this.hasTitle ) {
4021					buttonElement.attr( "title", $.trim( buttonText ) );
4022				}
4023			}
4024		} else {
4025			buttonClasses.push( "ui-button-text-only" );
4026		}
4027		buttonElement.addClass( buttonClasses.join( " " ) );
4028	}
4029});
4030
4031$.widget( "ui.buttonset", {
4032	version: "1.11.1",
4033	options: {
4034		items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
4035	},
4036
4037	_create: function() {
4038		this.element.addClass( "ui-buttonset" );
4039	},
4040
4041	_init: function() {
4042		this.refresh();
4043	},
4044
4045	_setOption: function( key, value ) {
4046		if ( key === "disabled" ) {
4047			this.buttons.button( "option", key, value );
4048		}
4049
4050		this._super( key, value );
4051	},
4052
4053	refresh: function() {
4054		var rtl = this.element.css( "direction" ) === "rtl",
4055			allButtons = this.element.find( this.options.items ),
4056			existingButtons = allButtons.filter( ":ui-button" );
4057
4058		// Initialize new buttons
4059		allButtons.not( ":ui-button" ).button();
4060
4061		// Refresh existing buttons
4062		existingButtons.button( "refresh" );
4063
4064		this.buttons = allButtons
4065			.map(function() {
4066				return $( this ).button( "widget" )[ 0 ];
4067			})
4068				.removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
4069				.filter( ":first" )
4070					.addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
4071				.end()
4072				.filter( ":last" )
4073					.addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
4074				.end()
4075			.end();
4076	},
4077
4078	_destroy: function() {
4079		this.element.removeClass( "ui-buttonset" );
4080		this.buttons
4081			.map(function() {
4082				return $( this ).button( "widget" )[ 0 ];
4083			})
4084				.removeClass( "ui-corner-left ui-corner-right" )
4085			.end()
4086			.button( "destroy" );
4087	}
4088});
4089
4090var button = $.ui.button;
4091
4092
4093/*!
4094 * jQuery UI Datepicker 1.11.1
4095 * http://jqueryui.com
4096 *
4097 * Copyright 2014 jQuery Foundation and other contributors
4098 * Released under the MIT license.
4099 * http://jquery.org/license
4100 *
4101 * http://api.jqueryui.com/datepicker/
4102 */
4103
4104
4105$.extend($.ui, { datepicker: { version: "1.11.1" } });
4106
4107var datepicker_instActive;
4108
4109function datepicker_getZindex( elem ) {
4110	var position, value;
4111	while ( elem.length && elem[ 0 ] !== document ) {
4112		// Ignore z-index if position is set to a value where z-index is ignored by the browser
4113		// This makes behavior of this function consistent across browsers
4114		// WebKit always returns auto if the element is positioned
4115		position = elem.css( "position" );
4116		if ( position === "absolute" || position === "relative" || position === "fixed" ) {
4117			// IE returns 0 when zIndex is not specified
4118			// other browsers return a string
4119			// we ignore the case of nested elements with an explicit value of 0
4120			// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
4121			value = parseInt( elem.css( "zIndex" ), 10 );
4122			if ( !isNaN( value ) && value !== 0 ) {
4123				return value;
4124			}
4125		}
4126		elem = elem.parent();
4127	}
4128
4129	return 0;
4130}
4131/* Date picker manager.
4132   Use the singleton instance of this class, $.datepicker, to interact with the date picker.
4133   Settings for (groups of) date pickers are maintained in an instance object,
4134   allowing multiple different settings on the same page. */
4135
4136function Datepicker() {
4137	this._curInst = null; // The current instance in use
4138	this._keyEvent = false; // If the last event was a key event
4139	this._disabledInputs = []; // List of date picker inputs that have been disabled
4140	this._datepickerShowing = false; // True if the popup picker is showing , false if not
4141	this._inDialog = false; // True if showing within a "dialog", false if not
4142	this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
4143	this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
4144	this._appendClass = "ui-datepicker-append"; // The name of the append marker class
4145	this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
4146	this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
4147	this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
4148	this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
4149	this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
4150	this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
4151	this.regional = []; // Available regional settings, indexed by language code
4152	this.regional[""] = { // Default regional settings
4153		closeText: "Done", // Display text for close link
4154		prevText: "Prev", // Display text for previous month link
4155		nextText: "Next", // Display text for next month link
4156		currentText: "Today", // Display text for current month link
4157		monthNames: ["January","February","March","April","May","June",
4158			"July","August","September","October","November","December"], // Names of months for drop-down and formatting
4159		monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
4160		dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
4161		dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
4162		dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
4163		weekHeader: "Wk", // Column header for week of the year
4164		dateFormat: "mm/dd/yy", // See format options on parseDate
4165		firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
4166		isRTL: false, // True if right-to-left language, false if left-to-right
4167		showMonthAfterYear: false, // True if the year select precedes month, false for month then year
4168		yearSuffix: "" // Additional text to append to the year in the month headers
4169	};
4170	this._defaults = { // Global defaults for all the date picker instances
4171		showOn: "focus", // "focus" for popup on focus,
4172			// "button" for trigger button, or "both" for either