https://portal3.tpmsmanager.com/scripts/jquery.1.11.4-jquery-ui.js…CT2eCgcbwiXFJiE76g1P_nEiRg6Y4EDkLNWv6_mDm0o

1/*! jQuery UI - v1.11.4 - 2015-03-11
2* http://jqueryui.com
3* Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
4* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
5
6(function (factory) {
7	if (typeof define === "function" && define.amd) {
8		// AMD. Register as an anonymous module.
9		define(["jquery"], factory);
10	} else {
11		// Browser globals
12		factory(jQuery);
13	}
14}(function ($) {
15	/*!
16	 * jQuery UI Core 1.11.4
17	 * http://jqueryui.com
18	 *
19	 * Copyright jQuery Foundation and other contributors
20	 * Released under the MIT license.
21	 * http://jquery.org/license
22	 *
23	 * http://api.jqueryui.com/category/ui-core/
24	 */
25
26	// $.ui might exist from components with no dependencies, e.g., $.ui.position
27	$.ui = $.ui || {};
28
29	$.extend($.ui, {
30		version: "1.11.4",
31
32		keyCode: {
33			BACKSPACE: 8,
34			COMMA: 188,
35			DELETE: 46,
36			DOWN: 40,
37			END: 35,
38			ENTER: 13,
39			ESCAPE: 27,
40			HOME: 36,
41			LEFT: 37,
42			PAGE_DOWN: 34,
43			PAGE_UP: 33,
44			PERIOD: 190,
45			RIGHT: 39,
46			SPACE: 32,
47			TAB: 9,
48			UP: 38
49		}
50	});
51
52	// plugins
53	$.fn.extend({
54		scrollParent: function (includeHidden) {
55			var position = this.css("position"),
56				excludeStaticParent = position === "absolute",
57				overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
58				scrollParent = this.parents().filter(function () {
59					var parent = $(this);
60					if (excludeStaticParent && parent.css("position") === "static") {
61						return false;
62					}
63					return overflowRegex.test(parent.css("overflow") + parent.css("overflow-y") + parent.css("overflow-x"));
64				}).eq(0);
65
66			return position === "fixed" || !scrollParent.length ? $(this[0].ownerDocument || document) : scrollParent;
67		},
68
69		uniqueId: (function () {
70			var uuid = 0;
71
72			return function () {
73				return this.each(function () {
74					if (!this.id) {
75						this.id = "ui-id-" + (++uuid);
76					}
77				});
78			};
79		})(),
80
81		removeUniqueId: function () {
82			return this.each(function () {
83				if (/^ui-id-\d+$/.test(this.id)) {
84					$(this).removeAttr("id");
85				}
86			});
87		}
88	});
89
90	// selectors
91	function focusable(element, isTabIndexNotNaN) {
92		var map, mapName, img,
93			nodeName = element.nodeName.toLowerCase();
94		if ("area" === nodeName) {
95			map = element.parentNode;
96			mapName = map.name;
97			if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
98				return false;
99			}
100			img = $("img[usemap='#" + mapName + "']")[0];
101			return !!img && visible(img);
102		}
103		return (/^(input|select|textarea|button|object)$/.test(nodeName) ?
104			!element.disabled :
105			"a" === nodeName ?
106				element.href || isTabIndexNotNaN :
107				isTabIndexNotNaN) &&
108			// the element and all of its ancestors must be visible
109			visible(element);
110	}
111
112	function visible(element) {
113		return $.expr.filters.visible(element) &&
114			!$(element).parents().addBack().filter(function () {
115				return $.css(this, "visibility") === "hidden";
116			}).length;
117	}
118
119	$.extend($.expr[":"], {
120		data: $.expr.createPseudo ?
121			$.expr.createPseudo(function (dataName) {
122				return function (elem) {
123					return !!$.data(elem, dataName);
124				};
125			}) :
126			// support: jQuery <1.8
127			function (elem, i, match) {
128				return !!$.data(elem, match[3]);
129			},
130
131		focusable: function (element) {
132			return focusable(element, !isNaN($.attr(element, "tabindex")));
133		},
134
135		tabbable: function (element) {
136			var tabIndex = $.attr(element, "tabindex"),
137				isTabIndexNaN = isNaN(tabIndex);
138			return (isTabIndexNaN || tabIndex >= 0) && focusable(element, !isTabIndexNaN);
139		}
140	});
141
142	// support: jQuery <1.8
143	if (!$("<a>").outerWidth(1).jquery) {
144		$.each(["Width", "Height"], function (i, name) {
145			var side = name === "Width" ? ["Left", "Right"] : ["Top", "Bottom"],
146				type = name.toLowerCase(),
147				orig = {
148					innerWidth: $.fn.innerWidth,
149					innerHeight: $.fn.innerHeight,
150					outerWidth: $.fn.outerWidth,
151					outerHeight: $.fn.outerHeight
152				};
153
154			function reduce(elem, size, border, margin) {
155				$.each(side, function () {
156					size -= parseFloat($.css(elem, "padding" + this)) || 0;
157					if (border) {
158						size -= parseFloat($.css(elem, "border" + this + "Width")) || 0;
159					}
160					if (margin) {
161						size -= parseFloat($.css(elem, "margin" + this)) || 0;
162					}
163				});
164				return size;
165			}
166
167			$.fn["inner" + name] = function (size) {
168				if (size === undefined) {
169					return orig["inner" + name].call(this);
170				}
171
172				return this.each(function () {
173					$(this).css(type, reduce(this, size) + "px");
174				});
175			};
176
177			$.fn["outer" + name] = function (size, margin) {
178				if (typeof size !== "number") {
179					return orig["outer" + name].call(this, size);
180				}
181
182				return this.each(function () {
183					$(this).css(type, reduce(this, size, true, margin) + "px");
184				});
185			};
186		});
187	}
188
189	// support: jQuery <1.8
190	if (!$.fn.addBack) {
191		$.fn.addBack = function (selector) {
192			return this.add(selector == null ?
193				this.prevObject : this.prevObject.filter(selector)
194			);
195		};
196	}
197
198	// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
199	if ($("<a>").data("a-b", "a").removeData("a-b").data("a-b")) {
200		$.fn.removeData = (function (removeData) {
201			return function (key) {
202				if (arguments.length) {
203					return removeData.call(this, $.camelCase(key));
204				} else {
205					return removeData.call(this);
206				}
207			};
208		})($.fn.removeData);
209	}
210
211	// deprecated
212	$.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());
213
214	$.fn.extend({
215		focus: (function (orig) {
216			return function (delay, fn) {
217				return typeof delay === "number" ?
218					this.each(function () {
219						var elem = this;
220						setTimeout(function () {
221							$(elem).focus();
222							if (fn) {
223								fn.call(elem);
224							}
225						}, delay);
226					}) :
227					orig.apply(this, arguments);
228			};
229		})($.fn.focus),
230
231		disableSelection: (function () {
232			var eventType = "onselectstart" in document.createElement("div") ?
233				"selectstart" :
234				"mousedown";
235
236			return function () {
237				return this.bind(eventType + ".ui-disableSelection", function (event) {
238					event.preventDefault();
239				});
240			};
241		})(),
242
243		enableSelection: function () {
244			return this.unbind(".ui-disableSelection");
245		},
246
247		zIndex: function (zIndex) {
248			if (zIndex !== undefined) {
249				return this.css("zIndex", zIndex);
250			}
251
252			if (this.length) {
253				var elem = $(this[0]), position, value;
254				while (elem.length && elem[0] !== document) {
255					// Ignore z-index if position is set to a value where z-index is ignored by the browser
256					// This makes behavior of this function consistent across browsers
257					// WebKit always returns auto if the element is positioned
258					position = elem.css("position");
259					if (position === "absolute" || position === "relative" || position === "fixed") {
260						// IE returns 0 when zIndex is not specified
261						// other browsers return a string
262						// we ignore the case of nested elements with an explicit value of 0
263						// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
264						value = parseInt(elem.css("zIndex"), 10);
265						if (!isNaN(value) && value !== 0) {
266							return value;
267						}
268					}
269					elem = elem.parent();
270				}
271			}
272
273			return 0;
274		}
275	});
276
277	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
278	$.ui.plugin = {
279		add: function (module, option, set) {
280			var i,
281				proto = $.ui[module].prototype;
282			for (i in set) {
283				proto.plugins[i] = proto.plugins[i] || [];
284				proto.plugins[i].push([option, set[i]]);
285			}
286		},
287		call: function (instance, name, args, allowDisconnected) {
288			var i,
289				set = instance.plugins[name];
290
291			if (!set) {
292				return;
293			}
294
295			if (!allowDisconnected && (!instance.element[0].parentNode || instance.element[0].parentNode.nodeType === 11)) {
296				return;
297			}
298
299			for (i = 0; i < set.length; i++) {
300				if (instance.options[set[i][0]]) {
301					set[i][1].apply(instance.element, args);
302				}
303			}
304		}
305	};
306
307	/*!
308	 * jQuery UI Widget 1.11.4
309	 * http://jqueryui.com
310	 *
311	 * Copyright jQuery Foundation and other contributors
312	 * Released under the MIT license.
313	 * http://jquery.org/license
314	 *
315	 * http://api.jqueryui.com/jQuery.widget/
316	 */
317
318	var widget_uuid = 0,
319		widget_slice = Array.prototype.slice;
320
321	$.cleanData = (function (orig) {
322		return function (elems) {
323			var events, elem, i;
324			for (i = 0; (elem = elems[i]) != null; i++) {
325				try {
326					// Only trigger remove when necessary to save time
327					events = $._data(elem, "events");
328					if (events && events.remove) {
329						$(elem).triggerHandler("remove");
330					}
331
332					// http://bugs.jquery.com/ticket/8235
333				} catch (e) { }
334			}
335			orig(elems);
336		};
337	})($.cleanData);
338
339	$.widget = function (name, base, prototype) {
340		var fullName, existingConstructor, constructor, basePrototype,
341			// proxiedPrototype allows the provided prototype to remain unmodified
342			// so that it can be used as a mixin for multiple widgets (#8876)
343			proxiedPrototype = {},
344			namespace = name.split(".")[0];
345
346		name = name.split(".")[1];
347		fullName = namespace + "-" + name;
348
349		if (!prototype) {
350			prototype = base;
351			base = $.Widget;
352		}
353
354		// create selector for plugin
355		$.expr[":"][fullName.toLowerCase()] = function (elem) {
356			return !!$.data(elem, fullName);
357		};
358
359		$[namespace] = $[namespace] || {};
360		existingConstructor = $[namespace][name];

361		constructor = $[namespace][name] = function (options, element) {
362			// allow instantiation without "new" keyword
363			if (!this._createWidget) {
364				return new constructor(options, element);
365			}
366
367			// allow instantiation without initializing for simple inheritance
368			// must use "new" keyword (the code above always passes args)
369			if (arguments.length) {
370				this._createWidget(options, element);
371			}
372		};
373		// extend with the existing constructor to carry over any static properties
374		$.extend(constructor, existingConstructor, {
375			version: prototype.version,
376			// copy the object used to create the prototype in case we need to
377			// redefine the widget later
378			_proto: $.extend({}, prototype),
379			// track widgets that inherit from this widget in case this widget is
380			// redefined after a widget inherits from it
381			_childConstructors: []
382		});
383
384		basePrototype = new base();
385		// we need to make the options hash a property directly on the new instance
386		// otherwise we'll modify the options hash on the prototype that we're
387		// inheriting from
388		basePrototype.options = $.widget.extend({}, basePrototype.options);
389		$.each(prototype, function (prop, value) {
390			if (!$.isFunction(value)) {
391				proxiedPrototype[prop] = value;
392				return;
393			}
394			proxiedPrototype[prop] = (function () {
395				var _super = function () {
396					return base.prototype[prop].apply(this, arguments);
397				},
398					_superApply = function (args) {
399						return base.prototype[prop].apply(this, args);
400					};
401				return function () {
402					var __super = this._super,
403						__superApply = this._superApply,
404						returnValue;
405
406					this._super = _super;
407					this._superApply = _superApply;
408
409					returnValue = value.apply(this, arguments);
410
411					this._super = __super;
412					this._superApply = __superApply;
413
414					return returnValue;
415				};
416			})();
417		});
418		constructor.prototype = $.widget.extend(basePrototype, {
419			// TODO: remove support for widgetEventPrefix
420			// always use the name + a colon as the prefix, e.g., draggable:start
421			// don't prefix for widgets that aren't DOM-based
422			widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
423		}, proxiedPrototype, {
424			constructor: constructor,
425			namespace: namespace,
426			widgetName: name,
427			widgetFullName: fullName
428		});
429
430		// If this widget is being redefined then we need to find all widgets that
431		// are inheriting from it and redefine all of them so that they inherit from
432		// the new version of this widget. We're essentially trying to replace one
433		// level in the prototype chain.
434		if (existingConstructor) {
435			$.each(existingConstructor._childConstructors, function (i, child) {
436				var childPrototype = child.prototype;
437
438				// redefine the child widget using the same prototype that was
439				// originally used, but inherit from the new version of the base
440				$.widget(childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto);
441			});
442			// remove the list of existing child constructors from the old constructor
443			// so the old child constructors can be garbage collected
444			delete existingConstructor._childConstructors;
445		} else {
446			base._childConstructors.push(constructor);
447		}
448
449		$.widget.bridge(name, constructor);
450
451		return constructor;
452	};
453
454	$.widget.extend = function (target) {
455		var input = widget_slice.call(arguments, 1),
456			inputIndex = 0,
457			inputLength = input.length,
458			key,
459			value;
460		for (; inputIndex < inputLength; inputIndex++) {
461			for (key in input[inputIndex]) {
462				value = input[inputIndex][key];
463				if (input[inputIndex].hasOwnProperty(key) && value !== undefined) {
464					// Clone objects
465					if ($.isPlainObject(value)) {
466						target[key] = $.isPlainObject(target[key]) ?
467							$.widget.extend({}, target[key], value) :
468							// Don't extend strings, arrays, etc. with objects
469							$.widget.extend({}, value);
470						// Copy everything else by reference
471					} else {
472						target[key] = value;
473					}
474				}
475			}
476		}
477		return target;
478	};
479
480	$.widget.bridge = function (name, object) {
481		var fullName = object.prototype.widgetFullName || name;
482		$.fn[name] = function (options) {
483			var isMethodCall = typeof options === "string",
484				args = widget_slice.call(arguments, 1),
485				returnValue = this;
486
487			if (isMethodCall) {
488				this.each(function () {
489					var methodValue,
490						instance = $.data(this, fullName);
491					if (options === "instance") {
492						returnValue = instance;
493						return false;
494					}
495					if (!instance) {
496						return $.error("cannot call methods on " + name + " prior to initialization; " +
497							"attempted to call method '" + options + "'");
498					}
499					if (!$.isFunction(instance[options]) || options.charAt(0) === "_") {
500						return $.error("no such method '" + options + "' for " + name + " widget instance");
501					}
502					methodValue = instance[options].apply(instance, args);
503					if (methodValue !== instance && methodValue !== undefined) {
504						returnValue = methodValue && methodValue.jquery ?
505							returnValue.pushStack(methodValue.get()) :
506							methodValue;
507						return false;
508					}
509				});
510			} else {
511				// Allow multiple hashes to be passed on init
512				if (args.length) {
513					options = $.widget.extend.apply(null, [options].concat(args));
514				}
515
516				this.each(function () {
517					var instance = $.data(this, fullName);
518					if (instance) {
519						instance.option(options || {});
520						if (instance._init) {
521							instance._init();
522						}
523					} else {
524						$.data(this, fullName, new object(options, this));
525					}
526				});
527			}
528
529			return returnValue;
530		};
531	};
532
533	$.Widget = function ( /* options, element */) { };
534	$.Widget._childConstructors = [];
535
536	$.Widget.prototype = {
537		widgetName: "widget",
538		widgetEventPrefix: "",
539		defaultElement: "<div>",
540		options: {
541			disabled: false,
542
543			// callbacks
544			create: null
545		},
546		_createWidget: function (options, element) {
547			element = $(element || this.defaultElement || this)[0];
548			this.element = $(element);
549			this.uuid = widget_uuid++;
550			this.eventNamespace = "." + this.widgetName + this.uuid;
551
552			this.bindings = $();
553			this.hoverable = $();
554			this.focusable = $();
555
556			if (element !== this) {
557				$.data(element, this.widgetFullName, this);
558				this._on(true, this.element, {
559					remove: function (event) {
560						if (event.target === element) {
561							this.destroy();
562						}
563					}
564				});
565				this.document = $(element.style ?
566					// element within the document
567					element.ownerDocument :
568					// element is window or document
569					element.document || element);
570				this.window = $(this.document[0].defaultView || this.document[0].parentWindow);
571			}
572
573			this.options = $.widget.extend({},
574				this.options,
575				this._getCreateOptions(),
576				options);
577
578			this._create();
579			this._trigger("create", null, this._getCreateEventData());
580			this._init();
581		},
582		_getCreateOptions: $.noop,
583		_getCreateEventData: $.noop,
584		_create: $.noop,
585		_init: $.noop,
586
587		destroy: function () {
588			this._destroy();
589			// we can probably remove the unbind calls in 2.0
590			// all event bindings should go through this._on()
591			this.element
592				.unbind(this.eventNamespace)
593				.removeData(this.widgetFullName)
594				// support: jquery <1.6.3
595				// http://bugs.jquery.com/ticket/9413
596				.removeData($.camelCase(this.widgetFullName));
597			this.widget()
598				.unbind(this.eventNamespace)
599				.removeAttr("aria-disabled")
600				.removeClass(
601					this.widgetFullName + "-disabled " +
602					"ui-state-disabled");
603
604			// clean up events and states
605			this.bindings.unbind(this.eventNamespace);
606			this.hoverable.removeClass("ui-state-hover");
607			this.focusable.removeClass("ui-state-focus");
608		},
609		_destroy: $.noop,
610
611		widget: function () {
612			return this.element;
613		},
614
615		option: function (key, value) {
616			var options = key,
617				parts,
618				curOption,
619				i;
620
621			if (arguments.length === 0) {
622				// don't return a reference to the internal hash
623				return $.widget.extend({}, this.options);
624			}
625
626			if (typeof key === "string") {
627				// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
628				options = {};
629				parts = key.split(".");
630				key = parts.shift();
631				if (parts.length) {
632					curOption = options[key] = $.widget.extend({}, this.options[key]);
633					for (i = 0; i < parts.length - 1; i++) {
634						curOption[parts[i]] = curOption[parts[i]] || {};
635						curOption = curOption[parts[i]];
636					}
637					key = parts.pop();
638					if (arguments.length === 1) {
639						return curOption[key] === undefined ? null : curOption[key];
640					}
641					curOption[key] = value;
642				} else {
643					if (arguments.length === 1) {
644						return this.options[key] === undefined ? null : this.options[key];
645					}
646					options[key] = value;
647				}
648			}
649
650			this._setOptions(options);
651
652			return this;
653		},
654		_setOptions: function (options) {
655			var key;
656
657			for (key in options) {
658				this._setOption(key, options[key]);
659			}
660
661			return this;
662		},
663		_setOption: function (key, value) {
664			this.options[key] = value;
665
666			if (key === "disabled") {
667				this.widget()
668					.toggleClass(this.widgetFullName + "-disabled", !!value);
669
670				// If the widget is becoming disabled, then nothing is interactive
671				if (value) {
672					this.hoverable.removeClass("ui-state-hover");
673					this.focusable.removeClass("ui-state-focus");
674				}
675			}
676
677			return this;
678		},
679
680		enable: function () {
681			return this._setOptions({ disabled: false });
682		},
683		disable: function () {
684			return this._setOptions({ disabled: true });
685		},
686
687		_on: function (suppressDisabledCheck, element, handlers) {
688			var delegateElement,
689				instance = this;
690
691			// no suppressDisabledCheck flag, shuffle arguments
692			if (typeof suppressDisabledCheck !== "boolean") {
693				handlers = element;
694				element = suppressDisabledCheck;
695				suppressDisabledCheck = false;
696			}
697
698			// no element argument, shuffle and use this.element
699			if (!handlers) {
700				handlers = element;
701				element = this.element;
702				delegateElement = this.widget();
703			} else {
704				element = delegateElement = $(element);
705				this.bindings = this.bindings.add(element);
706			}
707
708			$.each(handlers, function (event, handler) {
709				function handlerProxy() {
710					// allow widgets to customize the disabled handling
711					// - disabled as an array instead of boolean
712					// - disabled class as method for disabling individual parts
713					if (!suppressDisabledCheck &&
714							(instance.options.disabled === true ||
715								$(this).hasClass("ui-state-disabled"))) {
716						return;
717					}
718					return (typeof handler === "string" ? instance[handler] : handler)
719						.apply(instance, arguments);
720				}
721
722				// copy the guid so direct unbinding works
723				if (typeof handler !== "string") {
724					handlerProxy.guid = handler.guid =
725						handler.guid || handlerProxy.guid || $.guid++;
726				}
727
728				var match = event.match(/^([\w:-]*)\s*(.*)$/),
729					eventName = match[1] + instance.eventNamespace,
730					selector = match[2];
731				if (selector) {
732					delegateElement.delegate(selector, eventName, handlerProxy);
733				} else {
734					element.bind(eventName, handlerProxy);
735				}
736			});
737		},
738
739		_off: function (element, eventName) {
740			eventName = (eventName || "").split(" ").join(this.eventNamespace + " ") +
741				this.eventNamespace;
742			element.unbind(eventName).undelegate(eventName);
743
744			// Clear the stack to avoid memory leaks (#10056)
745			this.bindings = $(this.bindings.not(element).get());
746			this.focusable = $(this.focusable.not(element).get());
747			this.hoverable = $(this.hoverable.not(element).get());
748		},
749
750		_delay: function (handler, delay) {
751			function handlerProxy() {
752				return (typeof handler === "string" ? instance[handler] : handler)
753					.apply(instance, arguments);
754			}
755			var instance = this;
756			return setTimeout(handlerProxy, delay || 0);
757		},
758
759		_hoverable: function (element) {
760			this.hoverable = this.hoverable.add(element);
761			this._on(element, {
762				mouseenter: function (event) {
763					$(event.currentTarget).addClass("ui-state-hover");
764				},
765				mouseleave: function (event) {
766					$(event.currentTarget).removeClass("ui-state-hover");
767				}
768			});
769		},
770
771		_focusable: function (element) {
772			this.focusable = this.focusable.add(element);
773			this._on(element, {
774				focusin: function (event) {
775					$(event.currentTarget).addClass("ui-state-focus");
776				},
777				focusout: function (event) {
778					$(event.currentTarget).removeClass("ui-state-focus");
779				}
780			});
781		},
782
783		_trigger: function (type, event, data) {
784			var prop, orig,
785				callback = this.options[type];
786
787			data = data || {};
788			event = $.Event(event);
789			event.type = (type === this.widgetEventPrefix ?
790				type :
791				this.widgetEventPrefix + type).toLowerCase();
792			// the original event may come from any element
793			// so we need to reset the target on the new event
794			event.target = this.element[0];
795
796			// copy original event properties over to the new event
797			orig = event.originalEvent;
798			if (orig) {
799				for (prop in orig) {
800					if (!(prop in event)) {
801						event[prop] = orig[prop];
802					}
803				}
804			}
805
806			this.element.trigger(event, data);
807			return !($.isFunction(callback) &&
808				callback.apply(this.element[0], [event].concat(data)) === false ||
809				event.isDefaultPrevented());
810		}
811	};
812
813	$.each({ show: "fadeIn", hide: "fadeOut" }, function (method, defaultEffect) {
814		$.Widget.prototype["_" + method] = function (element, options, callback) {
815			if (typeof options === "string") {
816				options = { effect: options };
817			}
818			var hasOptions,
819				effectName = !options ?
820				method :
821					options === true || typeof options === "number" ?
822				defaultEffect :
823						options.effect || defaultEffect;
824			options = options || {};
825			if (typeof options === "number") {
826				options = { duration: options };
827			}
828			hasOptions = !$.isEmptyObject(options);
829			options.complete = callback;
830			if (options.delay) {
831				element.delay(options.delay);
832			}
833			if (hasOptions && $.effects && $.effects.effect[effectName]) {
834				element[method](options);
835			} else if (effectName !== method && element[effectName]) {
836				element[effectName](options.duration, options.easing, callback);
837			} else {
838				element.queue(function (next) {
839					$(this)[method]();
840					if (callback) {
841						callback.call(element[0]);
842					}
843					next();
844				});
845			}
846		};
847	});
848
849	var widget = $.widget;
850
851	/*!
852	 * jQuery UI Mouse 1.11.4
853	 * http://jqueryui.com
854	 *
855	 * Copyright jQuery Foundation and other contributors
856	 * Released under the MIT license.
857	 * http://jquery.org/license
858	 *
859	 * http://api.jqueryui.com/mouse/
860	 */
861
862	var mouseHandled = false;
863	$(document).mouseup(function () {
864		mouseHandled = false;
865	});
866
867	var mouse = $.widget("ui.mouse", {
868		version: "1.11.4",
869		options: {
870			cancel: "input,textarea,button,select,option",
871			distance: 1,
872			delay: 0
873		},
874		_mouseInit: function () {
875			var that = this;
876
877			this.element
878				.bind("mousedown." + this.widgetName, function (event) {
879					return that._mouseDown(event);
880				})
881				.bind("click." + this.widgetName, function (event) {
882					if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
883						$.removeData(event.target, that.widgetName + ".preventClickEvent");
884						event.stopImmediatePropagation();
885						return false;
886					}
887				});
888
889			this.started = false;
890		},
891
892		// TODO: make sure destroying one instance of mouse doesn't mess with
893		// other instances of mouse
894		_mouseDestroy: function () {
895			this.element.unbind("." + this.widgetName);
896			if (this._mouseMoveDelegate) {
897				this.document
898					.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
899					.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
900			}
901		},
902
903		_mouseDown: function (event) {
904			// don't let more than one widget handle mouseStart
905			if (mouseHandled) {
906				return;
907			}
908
909			this._mouseMoved = false;
910
911			// we may have missed mouseup (out of window)
912			(this._mouseStarted && this._mouseUp(event));
913
914			this._mouseDownEvent = event;
915
916			var that = this,
917				btnIsLeft = (event.which === 1),
918				// event.target.nodeName works around a bug in IE 8 with
919				// disabled inputs (#7620)
920				elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
921			if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
922				return true;
923			}
924
925			this.mouseDelayMet = !this.options.delay;
926			if (!this.mouseDelayMet) {
927				this._mouseDelayTimer = setTimeout(function () {
928					that.mouseDelayMet = true;
929				}, this.options.delay);
930			}
931
932			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
933				this._mouseStarted = (this._mouseStart(event) !== false);
934				if (!this._mouseStarted) {
935					event.preventDefault();
936					return true;
937				}
938			}
939
940			// Click event may never have fired (Gecko & Opera)
941			if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
942				$.removeData(event.target, this.widgetName + ".preventClickEvent");
943			}
944
945			// these delegates are required to keep context
946			this._mouseMoveDelegate = function (event) {
947				return that._mouseMove(event);
948			};
949			this._mouseUpDelegate = function (event) {
950				return that._mouseUp(event);
951			};
952
953			this.document
954				.bind("mousemove." + this.widgetName, this._mouseMoveDelegate)
955				.bind("mouseup." + this.widgetName, this._mouseUpDelegate);
956
957			event.preventDefault();
958
959			mouseHandled = true;
960			return true;
961		},
962
963		_mouseMove: function (event) {
964			// Only check for mouseups outside the document if you've moved inside the document
965			// at least once. This prevents the firing of mouseup in the case of IE<9, which will
966			// fire a mousemove event if content is placed under the cursor. See #7778
967			// Support: IE <9
968			if (this._mouseMoved) {
969				// IE mouseup check - mouseup happened when mouse was out of window
970				if ($.ui.ie && (!document.documentMode || document.documentMode < 9) && !event.button) {
971					return this._mouseUp(event);
972
973					// Iframe mouseup check - mouseup occurred in another document
974				} else if (!event.which) {
975					return this._mouseUp(event);
976				}
977			}
978
979			if (event.which || event.button) {
980				this._mouseMoved = true;
981			}
982
983			if (this._mouseStarted) {
984				this._mouseDrag(event);
985				return event.preventDefault();
986			}
987
988			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
989				this._mouseStarted =
990					(this._mouseStart(this._mouseDownEvent, event) !== false);
991				(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
992			}
993
994			return !this._mouseStarted;
995		},
996
997		_mouseUp: function (event) {
998			this.document
999				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
1000				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
1001
1002			if (this._mouseStarted) {
1003				this._mouseStarted = false;

1004
1005				if (event.target === this._mouseDownEvent.target) {
1006					$.data(event.target, this.widgetName + ".preventClickEvent", true);
1007				}
1008
1009				this._mouseStop(event);
1010			}
1011
1012			mouseHandled = false;
1013			return false;
1014		},
1015
1016		_mouseDistanceMet: function (event) {
1017			return (Math.max(
1018					Math.abs(this._mouseDownEvent.pageX - event.pageX),
1019					Math.abs(this._mouseDownEvent.pageY - event.pageY)
1020				) >= this.options.distance
1021			);
1022		},
1023
1024		_mouseDelayMet: function (/* event */) {
1025			return this.mouseDelayMet;
1026		},
1027
1028		// These are placeholder methods, to be overriden by extending plugin
1029		_mouseStart: function (/* event */) { },
1030		_mouseDrag: function (/* event */) { },
1031		_mouseStop: function (/* event */) { },
1032		_mouseCapture: function (/* event */) { return true; }
1033	});
1034
1035	/*!
1036	 * jQuery UI Position 1.11.4
1037	 * http://jqueryui.com
1038	 *
1039	 * Copyright jQuery Foundation and other contributors
1040	 * Released under the MIT license.
1041	 * http://jquery.org/license
1042	 *
1043	 * http://api.jqueryui.com/position/
1044	 */
1045
1046	(function () {
1047		$.ui = $.ui || {};
1048
1049		var cachedScrollbarWidth, supportsOffsetFractions,
1050			max = Math.max,
1051			abs = Math.abs,
1052			round = Math.round,
1053			rhorizontal = /left|center|right/,
1054			rvertical = /top|center|bottom/,
1055			roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1056			rposition = /^\w+/,
1057			rpercent = /%$/,
1058			_position = $.fn.position;
1059
1060		function getOffsets(offsets, width, height) {
1061			return [
1062				parseFloat(offsets[0]) * (rpercent.test(offsets[0]) ? width / 100 : 1),
1063				parseFloat(offsets[1]) * (rpercent.test(offsets[1]) ? height / 100 : 1)
1064			];
1065		}
1066
1067		function parseCss(element, property) {
1068			return parseInt($.css(element, property), 10) || 0;
1069		}
1070
1071		function getDimensions(elem) {
1072			var raw = elem[0];
1073			if (raw.nodeType === 9) {
1074				return {
1075					width: elem.width(),
1076					height: elem.height(),
1077					offset: { top: 0, left: 0 }
1078				};
1079			}
1080			if ($.isWindow(raw)) {
1081				return {
1082					width: elem.width(),
1083					height: elem.height(),
1084					offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1085				};
1086			}
1087			if (raw.preventDefault) {
1088				return {
1089					width: 0,
1090					height: 0,
1091					offset: { top: raw.pageY, left: raw.pageX }
1092				};
1093			}
1094			return {
1095				width: elem.outerWidth(),
1096				height: elem.outerHeight(),
1097				offset: elem.offset()
1098			};
1099		}
1100
1101		$.position = {
1102			scrollbarWidth: function () {
1103				if (cachedScrollbarWidth !== undefined) {
1104					return cachedScrollbarWidth;
1105				}
1106				var w1, w2,
1107					div = $("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),
1108					innerDiv = div.children()[0];
1109
1110				$("body").append(div);
1111				w1 = innerDiv.offsetWidth;
1112				div.css("overflow", "scroll");
1113
1114				w2 = innerDiv.offsetWidth;
1115
1116				if (w1 === w2) {
1117					w2 = div[0].clientWidth;
1118				}
1119
1120				div.remove();
1121
1122				return (cachedScrollbarWidth = w1 - w2);
1123			},
1124			getScrollInfo: function (within) {
1125				var overflowX = within.isWindow || within.isDocument ? "" :
1126						within.element.css("overflow-x"),
1127					overflowY = within.isWindow || within.isDocument ? "" :
1128						within.element.css("overflow-y"),
1129					hasOverflowX = overflowX === "scroll" ||
1130						(overflowX === "auto" && within.width < within.element[0].scrollWidth),
1131					hasOverflowY = overflowY === "scroll" ||
1132						(overflowY === "auto" && within.height < within.element[0].scrollHeight);
1133				return {
1134					width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1135					height: hasOverflowX ? $.position.scrollbarWidth() : 0
1136				};
1137			},
1138			getWithinInfo: function (element) {
1139				var withinElement = $(element || window),
1140					isWindow = $.isWindow(withinElement[0]),
1141					isDocument = !!withinElement[0] && withinElement[0].nodeType === 9;
1142				return {
1143					element: withinElement,
1144					isWindow: isWindow,
1145					isDocument: isDocument,
1146					offset: withinElement.offset() || { left: 0, top: 0 },
1147					scrollLeft: withinElement.scrollLeft(),
1148					scrollTop: withinElement.scrollTop(),
1149
1150					// support: jQuery 1.6.x
1151					// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1152					width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1153					height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1154				};
1155			}
1156		};
1157
1158		$.fn.position = function (options) {
1159			if (!options || !options.of) {
1160				return _position.apply(this, arguments);
1161			}
1162
1163			// make a copy, we don't want to modify arguments
1164			options = $.extend({}, options);
1165
1166			var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1167				target = $(options.of),
1168				within = $.position.getWithinInfo(options.within),
1169				scrollInfo = $.position.getScrollInfo(within),
1170				collision = (options.collision || "flip").split(" "),
1171				offsets = {};
1172
1173			dimensions = getDimensions(target);
1174			if (target[0].preventDefault) {
1175				// force left top to allow flipping
1176				options.at = "left top";
1177			}
1178			targetWidth = dimensions.width;
1179			targetHeight = dimensions.height;
1180			targetOffset = dimensions.offset;
1181			// clone to reuse original targetOffset later
1182			basePosition = $.extend({}, targetOffset);
1183
1184			// force my and at to have valid horizontal and vertical positions
1185			// if a value is missing or invalid, it will be converted to center
1186			$.each(["my", "at"], function () {
1187				var pos = (options[this] || "").split(" "),
1188					horizontalOffset,
1189					verticalOffset;
1190
1191				if (pos.length === 1) {
1192					pos = rhorizontal.test(pos[0]) ?
1193						pos.concat(["center"]) :
1194						rvertical.test(pos[0]) ?
1195							["center"].concat(pos) :
1196							["center", "center"];
1197				}
1198				pos[0] = rhorizontal.test(pos[0]) ? pos[0] : "center";
1199				pos[1] = rvertical.test(pos[1]) ? pos[1] : "center";
1200
1201				// calculate offsets
1202				horizontalOffset = roffset.exec(pos[0]);
1203				verticalOffset = roffset.exec(pos[1]);
1204				offsets[this] = [
1205					horizontalOffset ? horizontalOffset[0] : 0,
1206					verticalOffset ? verticalOffset[0] : 0
1207				];
1208
1209				// reduce to just the positions without the offsets
1210				options[this] = [
1211					rposition.exec(pos[0])[0],
1212					rposition.exec(pos[1])[0]
1213				];
1214			});
1215
1216			// normalize collision option
1217			if (collision.length === 1) {
1218				collision[1] = collision[0];
1219			}
1220
1221			if (options.at[0] === "right") {
1222				basePosition.left += targetWidth;
1223			} else if (options.at[0] === "center") {
1224				basePosition.left += targetWidth / 2;
1225			}
1226
1227			if (options.at[1] === "bottom") {
1228				basePosition.top += targetHeight;
1229			} else if (options.at[1] === "center") {
1230				basePosition.top += targetHeight / 2;
1231			}
1232
1233			atOffset = getOffsets(offsets.at, targetWidth, targetHeight);
1234			basePosition.left += atOffset[0];
1235			basePosition.top += atOffset[1];
1236
1237			return this.each(function () {
1238				var collisionPosition, using,
1239					elem = $(this),
1240					elemWidth = elem.outerWidth(),
1241					elemHeight = elem.outerHeight(),
1242					marginLeft = parseCss(this, "marginLeft"),
1243					marginTop = parseCss(this, "marginTop"),
1244					collisionWidth = elemWidth + marginLeft + parseCss(this, "marginRight") + scrollInfo.width,
1245					collisionHeight = elemHeight + marginTop + parseCss(this, "marginBottom") + scrollInfo.height,
1246					position = $.extend({}, basePosition),
1247					myOffset = getOffsets(offsets.my, elem.outerWidth(), elem.outerHeight());
1248
1249				if (options.my[0] === "right") {
1250					position.left -= elemWidth;
1251				} else if (options.my[0] === "center") {
1252					position.left -= elemWidth / 2;
1253				}
1254
1255				if (options.my[1] === "bottom") {
1256					position.top -= elemHeight;
1257				} else if (options.my[1] === "center") {
1258					position.top -= elemHeight / 2;
1259				}
1260
1261				position.left += myOffset[0];
1262				position.top += myOffset[1];
1263
1264				// if the browser doesn't support fractions, then round for consistent results
1265				if (!supportsOffsetFractions) {
1266					position.left = round(position.left);
1267					position.top = round(position.top);
1268				}
1269
1270				collisionPosition = {
1271					marginLeft: marginLeft,
1272					marginTop: marginTop
1273				};
1274
1275				$.each(["left", "top"], function (i, dir) {
1276					if ($.ui.position[collision[i]]) {
1277						$.ui.position[collision[i]][dir](position, {
1278							targetWidth: targetWidth,
1279							targetHeight: targetHeight,
1280							elemWidth: elemWidth,
1281							elemHeight: elemHeight,
1282							collisionPosition: collisionPosition,
1283							collisionWidth: collisionWidth,
1284							collisionHeight: collisionHeight,
1285							offset: [atOffset[0] + myOffset[0], atOffset[1] + myOffset[1]],
1286							my: options.my,
1287							at: options.at,
1288							within: within,
1289							elem: elem
1290						});
1291					}
1292				});
1293
1294				if (options.using) {
1295					// adds feedback as second argument to using callback, if present
1296					using = function (props) {
1297						var left = targetOffset.left - position.left,
1298							right = left + targetWidth - elemWidth,
1299							top = targetOffset.top - position.top,
1300							bottom = top + targetHeight - elemHeight,
1301							feedback = {
1302								target: {
1303									element: target,
1304									left: targetOffset.left,
1305									top: targetOffset.top,
1306									width: targetWidth,
1307									height: targetHeight
1308								},
1309								element: {
1310									element: elem,
1311									left: position.left,
1312									top: position.top,
1313									width: elemWidth,
1314									height: elemHeight
1315								},
1316								horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1317								vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1318							};
1319						if (targetWidth < elemWidth && abs(left + right) < targetWidth) {
1320							feedback.horizontal = "center";
1321						}
1322						if (targetHeight < elemHeight && abs(top + bottom) < targetHeight) {
1323							feedback.vertical = "middle";
1324						}
1325						if (max(abs(left), abs(right)) > max(abs(top), abs(bottom))) {
1326							feedback.important = "horizontal";
1327						} else {
1328							feedback.important = "vertical";
1329						}
1330						options.using.call(this, props, feedback);
1331					};
1332				}
1333
1334				elem.offset($.extend(position, { using: using }));
1335			});
1336		};
1337
1338		$.ui.position = {
1339			fit: {
1340				left: function (position, data) {
1341					var within = data.within,
1342						withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1343						outerWidth = within.width,
1344						collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1345						overLeft = withinOffset - collisionPosLeft,
1346						overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1347						newOverRight;
1348
1349					// element is wider than within
1350					if (data.collisionWidth > outerWidth) {
1351						// element is initially over the left side of within
1352						if (overLeft > 0 && overRight <= 0) {
1353							newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1354							position.left += overLeft - newOverRight;
1355							// element is initially over right side of within
1356						} else if (overRight > 0 && overLeft <= 0) {
1357							position.left = withinOffset;
1358							// element is initially over both left and right sides of within
1359						} else {
1360							if (overLeft > overRight) {
1361								position.left = withinOffset + outerWidth - data.collisionWidth;
1362							} else {
1363								position.left = withinOffset;
1364							}
1365						}
1366						// too far left -> align with left edge
1367					} else if (overLeft > 0) {
1368						position.left += overLeft;
1369						// too far right -> align with right edge
1370					} else if (overRight > 0) {
1371						position.left -= overRight;
1372						// adjust based on position and margin
1373					} else {
1374						position.left = max(position.left - collisionPosLeft, position.left);
1375					}
1376				},
1377				top: function (position, data) {
1378					var within = data.within,
1379						withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1380						outerHeight = data.within.height,
1381						collisionPosTop = position.top - data.collisionPosition.marginTop,
1382						overTop = withinOffset - collisionPosTop,
1383						overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1384						newOverBottom;
1385
1386					// element is taller than within
1387					if (data.collisionHeight > outerHeight) {
1388						// element is initially over the top of within
1389						if (overTop > 0 && overBottom <= 0) {
1390							newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1391							position.top += overTop - newOverBottom;
1392							// element is initially over bottom of within
1393						} else if (overBottom > 0 && overTop <= 0) {
1394							position.top = withinOffset;
1395							// element is initially over both top and bottom of within
1396						} else {
1397							if (overTop > overBottom) {
1398								position.top = withinOffset + outerHeight - data.collisionHeight;
1399							} else {
1400								position.top = withinOffset;
1401							}
1402						}
1403						// too far up -> align with top
1404					} else if (overTop > 0) {
1405						position.top += overTop;
1406						// too far down -> align with bottom edge
1407					} else if (overBottom > 0) {
1408						position.top -= overBottom;
1409						// adjust based on position and margin
1410					} else {
1411						position.top = max(position.top - collisionPosTop, position.top);
1412					}
1413				}
1414			},
1415			flip: {
1416				left: function (position, data) {
1417					var within = data.within,
1418						withinOffset = within.offset.left + within.scrollLeft,
1419						outerWidth = within.width,
1420						offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1421						collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1422						overLeft = collisionPosLeft - offsetLeft,
1423						overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1424						myOffset = data.my[0] === "left" ?
1425							-data.elemWidth :
1426							data.my[0] === "right" ?
1427								data.elemWidth :
1428								0,
1429						atOffset = data.at[0] === "left" ?
1430							data.targetWidth :
1431							data.at[0] === "right" ?
1432								-data.targetWidth :
1433								0,
1434						offset = -2 * data.offset[0],
1435						newOverRight,
1436						newOverLeft;
1437
1438					if (overLeft < 0) {
1439						newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1440						if (newOverRight < 0 || newOverRight < abs(overLeft)) {
1441							position.left += myOffset + atOffset + offset;
1442						}
1443					} else if (overRight > 0) {
1444						newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1445						if (newOverLeft > 0 || abs(newOverLeft) < overRight) {
1446							position.left += myOffset + atOffset + offset;
1447						}
1448					}
1449				},
1450				top: function (position, data) {
1451					var within = data.within,
1452						withinOffset = within.offset.top + within.scrollTop,
1453						outerHeight = within.height,
1454						offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1455						collisionPosTop = position.top - data.collisionPosition.marginTop,
1456						overTop = collisionPosTop - offsetTop,
1457						overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1458						top = data.my[1] === "top",
1459						myOffset = top ?
1460							-data.elemHeight :
1461							data.my[1] === "bottom" ?
1462								data.elemHeight :
1463								0,
1464						atOffset = data.at[1] === "top" ?
1465							data.targetHeight :
1466							data.at[1] === "bottom" ?
1467								-data.targetHeight :
1468								0,
1469						offset = -2 * data.offset[1],
1470						newOverTop,
1471						newOverBottom;
1472					if (overTop < 0) {
1473						newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1474						if (newOverBottom < 0 || newOverBottom < abs(overTop)) {
1475							position.top += myOffset + atOffset + offset;
1476						}
1477					} else if (overBottom > 0) {
1478						newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1479						if (newOverTop > 0 || abs(newOverTop) < overBottom) {
1480							position.top += myOffset + atOffset + offset;
1481						}
1482					}
1483				}
1484			},
1485			flipfit: {
1486				left: function () {
1487					$.ui.position.flip.left.apply(this, arguments);
1488					$.ui.position.fit.left.apply(this, arguments);
1489				},
1490				top: function () {
1491					$.ui.position.flip.top.apply(this, arguments);
1492					$.ui.position.fit.top.apply(this, arguments);
1493				}
1494			}
1495		};
1496
1497		// fraction support test
1498		(function () {
1499			var testElement, testElementParent, testElementStyle, offsetLeft, i,
1500				body = document.getElementsByTagName("body")[0],
1501				div = document.createElement("div");
1502
1503			//Create a "fake body" for testing based on method used in jQuery.support
1504			testElement = document.createElement(body ? "div" : "body");
1505			testElementStyle = {
1506				visibility: "hidden",
1507				width: 0,
1508				height: 0,
1509				border: 0,
1510				margin: 0,
1511				background: "none"
1512			};
1513			if (body) {
1514				$.extend(testElementStyle, {
1515					position: "absolute",
1516					left: "-1000px",
1517					top: "-1000px"
1518				});
1519			}
1520			for (i in testElementStyle) {
1521				testElement.style[i] = testElementStyle[i];
1522			}
1523			testElement.appendChild(div);
1524			testElementParent = body || document.documentElement;
1525			testElementParent.insertBefore(testElement, testElementParent.firstChild);
1526
1527			div.style.cssText = "position: absolute; left: 10.7432222px;";
1528
1529			offsetLeft = $(div).offset().left;
1530			supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1531
1532			testElement.innerHTML = "";
1533			testElementParent.removeChild(testElement);
1534		})();
1535	})();
1536
1537	var position = $.ui.position;
1538
1539	/*!
1540	 * jQuery UI Accordion 1.11.4
1541	 * http://jqueryui.com
1542	 *
1543	 * Copyright jQuery Foundation and other contributors
1544	 * Released under the MIT license.
1545	 * http://jquery.org/license
1546	 *
1547	 * http://api.jqueryui.com/accordion/
1548	 */
1549
1550	var accordion = $.widget("ui.accordion", {
1551		version: "1.11.4",
1552		options: {
1553			active: 0,
1554			animate: {},
1555			collapsible: false,
1556			event: "click",
1557			header: "> li > :first-child,> :not(li):even",
1558			heightStyle: "auto",
1559			icons: {
1560				activeHeader: "ui-icon-triangle-1-s",
1561				header: "ui-icon-triangle-1-e"
1562			},
1563
1564			// callbacks
1565			activate: null,
1566			beforeActivate: null
1567		},
1568
1569		hideProps: {
1570			borderTopWidth: "hide",
1571			borderBottomWidth: "hide",
1572			paddingTop: "hide",
1573			paddingBottom: "hide",
1574			height: "hide"
1575		},
1576
1577		showProps: {
1578			borderTopWidth: "show",
1579			borderBottomWidth: "show",
1580			paddingTop: "show",
1581			paddingBottom: "show",
1582			height: "show"
1583		},
1584
1585		_create: function () {
1586			var options = this.options;
1587			this.prevShow = this.prevHide = $();
1588			this.element.addClass("ui-accordion ui-widget ui-helper-reset")
1589				// ARIA
1590				.attr("role", "tablist");
1591
1592			// don't allow collapsible: false and active: false / null
1593			if (!options.collapsible && (options.active === false || options.active == null)) {
1594				options.active = 0;
1595			}
1596
1597			this._processPanels();
1598			// handle negative values
1599			if (options.active < 0) {
1600				options.active += this.headers.length;
1601			}
1602			this._refresh();
1603		},
1604
1605		_getCreateEventData: function () {
1606			return {
1607				header: this.active,
1608				panel: !this.active.length ? $() : this.active.next()
1609			};
1610		},
1611
1612		_createIcons: function () {
1613			var icons = this.options.icons;
1614			if (icons) {
1615				$("<span>")
1616					.addClass("ui-accordion-header-icon ui-icon " + icons.header)
1617					.prependTo(this.headers);
1618				this.active.children(".ui-accordion-header-icon")
1619					.removeClass(icons.header)
1620					.addClass(icons.activeHeader);
1621				this.headers.addClass("ui-accordion-icons");
1622			}
1623		},
1624
1625		_destroyIcons: function () {
1626			this.headers
1627				.removeClass("ui-accordion-icons")
1628				.children(".ui-accordion-header-icon")
1629					.remove();
1630		},
1631
1632		_destroy: function () {
1633			var contents;
1634
1635			// clean up main element
1636			this.element
1637				.removeClass("ui-accordion ui-widget ui-helper-reset")
1638				.removeAttr("role");
1639
1640			// clean up headers
1641			this.headers
1642				.removeClass("ui-accordion-header ui-accordion-header-active ui-state-default " +
1643					"ui-corner-all ui-state-active ui-state-disabled ui-corner-top")
1644				.removeAttr("role")
1645				.removeAttr("aria-expanded")
1646				.removeAttr("aria-selected")
1647				.removeAttr("aria-controls")
1648				.removeAttr("tabIndex")
1649				.removeUniqueId();
1650
1651			this._destroyIcons();
1652
1653			// clean up content panels
1654			contents = this.headers.next()
1655				.removeClass("ui-helper-reset ui-widget-content ui-corner-bottom " +
1656					"ui-accordion-content ui-accordion-content-active ui-state-disabled")
1657				.css("display", "")
1658				.removeAttr("role")
1659				.removeAttr("aria-hidden")
1660				.removeAttr("aria-labelledby")
1661				.removeUniqueId();
1662
1663			if (this.options.heightStyle !== "content") {
1664				contents.css("height", "");
1665			}
1666		},
1667
1668		_setOption: function (key, value) {
1669			if (key === "active") {
1670				// _activate() will handle invalid values and update this.options
1671				this._activate(value);
1672				return;
1673			}
1674
1675			if (key === "event") {
1676				if (this.options.event) {
1677					this._off(this.headers, this.options.event);
1678				}
1679				this._setupEvents(value);
1680			}
1681
1682			this._super(key, value);
1683
1684			// setting collapsible: false while collapsed; open first panel
1685			if (key === "collapsible" && !value && this.options.active === false) {
1686				this._activate(0);
1687			}
1688
1689			if (key === "icons") {
1690				this._destroyIcons();
1691				if (value) {
1692					this._createIcons();
1693				}
1694			}
1695
1696			// #5332 - opacity doesn't cascade to positioned elements in IE
1697			// so we need to add the disabled class to the headers and panels
1698			if (key === "disabled") {
1699				this.element
1700					.toggleClass("ui-state-disabled", !!value)
1701					.attr("aria-disabled", value);
1702				this.headers.add(this.headers.next())
1703					.toggleClass("ui-state-disabled", !!value);
1704			}
1705		},
1706
1707		_keydown: function (event) {
1708			if (event.altKey || event.ctrlKey) {
1709				return;
1710			}
1711
1712			var keyCode = $.ui.keyCode,
1713				length = this.headers.length,
1714				currentIndex = this.headers.index(event.target),
1715				toFocus = false;
1716
1717			switch (event.keyCode) {
1718				case keyCode.RIGHT:
1719				case keyCode.DOWN:
1720					toFocus = this.headers[(currentIndex + 1) % length];
1721					break;
1722				case keyCode.LEFT:
1723				case keyCode.UP:
1724					toFocus = this.headers[(currentIndex - 1 + length) % length];
1725					break;
1726				case keyCode.SPACE:
1727				case keyCode.ENTER:
1728					this._eventHandler(event);
1729					break;
1730				case keyCode.HOME:
1731					toFocus = this.headers[0];
1732					break;
1733				case keyCode.END:
1734					toFocus = this.headers[length - 1];
1735					break;
1736			}
1737
1738			if (toFocus) {
1739				$(event.target).attr("tabIndex", -1);
1740				$(toFocus).attr("tabIndex", 0);
1741				toFocus.focus();
1742				event.preventDefault();
1743			}
1744		},
1745
1746		_panelKeyDown: function (event) {
1747			if (event.keyCode === $.ui.keyCode.UP && event.ctrlKey) {
1748				$(event.currentTarget).prev().focus();
1749			}
1750		},
1751
1752		refresh: function () {
1753			var options = this.options;
1754			this._processPanels();
1755
1756			// was collapsed or no panel
1757			if ((options.active === false && options.collapsible === true) || !this.headers.length) {
1758				options.active = false;

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

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

2558				// If we were passed an event, look for the submenu that contains the event
2559				var currentMenu = all ? this.element :
2560					$(event && event.target).closest(this.element.find(".ui-menu"));
2561
2562				// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2563				if (!currentMenu.length) {
2564					currentMenu = this.element;
2565				}
2566
2567				this._close(currentMenu);
2568
2569				this.blur(event);
2570				this.activeMenu = currentMenu;
2571			}, this.delay);
2572		},
2573
2574		// With no arguments, closes the currently active menu - if nothing is active
2575		// it closes all menus.  If passed an argument, it will search for menus BELOW
2576		_close: function (startMenu) {
2577			if (!startMenu) {
2578				startMenu = this.active ? this.active.parent() : this.element;
2579			}
2580
2581			startMenu
2582				.find(".ui-menu")
2583					.hide()
2584					.attr("aria-hidden", "true")
2585					.attr("aria-expanded", "false")
2586				.end()
2587				.find(".ui-state-active").not(".ui-state-focus")
2588					.removeClass("ui-state-active");
2589		},
2590
2591		_closeOnDocumentClick: function (event) {
2592			return !$(event.target).closest(".ui-menu").length;
2593		},
2594
2595		_isDivider: function (item) {
2596			// Match hyphen, em dash, en dash
2597			return !/[^\-\u2014\u2013\s]/.test(item.text());
2598		},
2599
2600		collapse: function (event) {
2601			var newItem = this.active &&
2602				this.active.parent().closest(".ui-menu-item", this.element);
2603			if (newItem && newItem.length) {
2604				this._close();
2605				this.focus(event, newItem);
2606			}
2607		},
2608
2609		expand: function (event) {
2610			var newItem = this.active &&
2611				this.active
2612					.children(".ui-menu ")
2613					.find(this.options.items)
2614					.first();
2615
2616			if (newItem && newItem.length) {
2617				this._open(newItem.parent());
2618
2619				// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2620				this._delay(function () {
2621					this.focus(event, newItem);
2622				});
2623			}
2624		},
2625
2626		next: function (event) {
2627			this._move("next", "first", event);
2628		},
2629
2630		previous: function (event) {
2631			this._move("prev", "last", event);
2632		},
2633
2634		isFirstItem: function () {
2635			return this.active && !this.active.prevAll(".ui-menu-item").length;
2636		},
2637
2638		isLastItem: function () {
2639			return this.active && !this.active.nextAll(".ui-menu-item").length;
2640		},
2641
2642		_move: function (direction, filter, event) {
2643			var next;
2644			if (this.active) {
2645				if (direction === "first" || direction === "last") {
2646					next = this.active
2647						[direction === "first" ? "prevAll" : "nextAll"](".ui-menu-item")
2648						.eq(-1);
2649				} else {
2650					next = this.active
2651						[direction + "All"](".ui-menu-item")
2652						.eq(0);
2653				}
2654			}
2655			if (!next || !next.length || !this.active) {
2656				next = this.activeMenu.find(this.options.items)[filter]();
2657			}
2658
2659			this.focus(event, next);
2660		},
2661
2662		nextPage: function (event) {
2663			var item, base, height;
2664
2665			if (!this.active) {
2666				this.next(event);
2667				return;
2668			}
2669			if (this.isLastItem()) {
2670				return;
2671			}
2672			if (this._hasScroll()) {
2673				base = this.active.offset().top;
2674				height = this.element.height();
2675				this.active.nextAll(".ui-menu-item").each(function () {
2676					item = $(this);
2677					return item.offset().top - base - height < 0;
2678				});
2679
2680				this.focus(event, item);
2681			} else {
2682				this.focus(event, this.activeMenu.find(this.options.items)
2683					[!this.active ? "first" : "last"]());
2684			}
2685		},
2686
2687		previousPage: function (event) {
2688			var item, base, height;
2689			if (!this.active) {
2690				this.next(event);
2691				return;
2692			}
2693			if (this.isFirstItem()) {
2694				return;
2695			}
2696			if (this._hasScroll()) {
2697				base = this.active.offset().top;
2698				height = this.element.height();
2699				this.active.prevAll(".ui-menu-item").each(function () {
2700					item = $(this);
2701					return item.offset().top - base + height > 0;
2702				});
2703
2704				this.focus(event, item);
2705			} else {
2706				this.focus(event, this.activeMenu.find(this.options.items).first());
2707			}
2708		},
2709
2710		_hasScroll: function () {
2711			return this.element.outerHeight() < this.element.prop("scrollHeight");
2712		},
2713
2714		select: function (event) {
2715			// TODO: It should never be possible to not have an active item at this
2716			// point, but the tests don't trigger mouseenter before click.
2717			this.active = this.active || $(event.target).closest(".ui-menu-item");
2718			var ui = { item: this.active };
2719			if (!this.active.has(".ui-menu").length) {
2720				this.collapseAll(event, true);
2721			}
2722			this._trigger("select", event, ui);
2723		},
2724
2725		_filterMenuItems: function (character) {
2726			var escapedCharacter = character.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"),
2727				regex = new RegExp("^" + escapedCharacter, "i");
2728
2729			return this.activeMenu
2730				.find(this.options.items)
2731
2732				// Only match on items, not dividers or other content (#10571)
2733				.filter(".ui-menu-item")
2734				.filter(function () {
2735					return regex.test($.trim($(this).text()));
2736				});
2737		}
2738	});
2739
2740	/*!
2741	 * jQuery UI Autocomplete 1.11.4
2742	 * http://jqueryui.com
2743	 *
2744	 * Copyright jQuery Foundation and other contributors
2745	 * Released under the MIT license.
2746	 * http://jquery.org/license
2747	 *
2748	 * http://api.jqueryui.com/autocomplete/
2749	 */
2750
2751	$.widget("ui.autocomplete", {
2752		version: "1.11.4",
2753		defaultElement: "<input>",
2754		options: {
2755			appendTo: null,
2756			autoFocus: false,
2757			delay: 300,
2758			minLength: 1,
2759			position: {
2760				my: "left top",
2761				at: "left bottom",
2762				collision: "none"
2763			},
2764			source: null,
2765
2766			// callbacks
2767			change: null,
2768			close: null,
2769			focus: null,
2770			open: null,
2771			response: null,
2772			search: null,
2773			select: null
2774		},
2775
2776		requestIndex: 0,
2777		pending: 0,
2778
2779		_create: function () {
2780			// Some browsers only repeat keydown events, not keypress events,
2781			// so we use the suppressKeyPress flag to determine if we've already
2782			// handled the keydown event. #7269
2783			// Unfortunately the code for & in keypress is the same as the up arrow,
2784			// so we use the suppressKeyPressRepeat flag to avoid handling keypress
2785			// events when we know the keydown event was used to modify the
2786			// search term. #7799
2787			var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2788				nodeName = this.element[0].nodeName.toLowerCase(),
2789				isTextarea = nodeName === "textarea",
2790				isInput = nodeName === "input";
2791
2792			this.isMultiLine =
2793				// Textareas are always multi-line
2794				isTextarea ? true :