diff --git a/app/assets/javascripts/app/lib/core/jquery-ui-1.11.4.js b/app/assets/javascripts/app/lib/core/jquery-ui-1.11.4.js
index 6e5062846..7623214af 100644
--- a/app/assets/javascripts/app/lib/core/jquery-ui-1.11.4.js
+++ b/app/assets/javascripts/app/lib/core/jquery-ui-1.11.4.js
@@ -1,6 +1,6 @@
-/*! jQuery UI - v1.11.4 - 2016-03-11
+/*! jQuery UI - v1.11.4 - 2016-03-12
 * http://jqueryui.com
-* Includes: core.js, widget.js, mouse.js, sortable.js, accordion.js
+* Includes: core.js, widget.js, mouse.js, position.js, sortable.js, accordion.js, autocomplete.js, menu.js
 * Copyright jQuery Foundation and other contributors; Licensed MIT */
 
 (function( factory ) {
@@ -1042,6 +1042,513 @@ var mouse = $.widget("ui.mouse", {
 });
 
 
+/*!
+ * jQuery UI Position 1.11.4
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/position/
+ */
+
+(function() {
+
+$.ui = $.ui || {};
+
+var cachedScrollbarWidth, supportsOffsetFractions,
+	max = Math.max,
+	abs = Math.abs,
+	round = Math.round,
+	rhorizontal = /left|center|right/,
+	rvertical = /top|center|bottom/,
+	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
+	rposition = /^\w+/,
+	rpercent = /%$/,
+	_position = $.fn.position;
+
+function getOffsets( offsets, width, height ) {
+	return [
+		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
+		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
+	];
+}
+
+function parseCss( element, property ) {
+	return parseInt( $.css( element, property ), 10 ) || 0;
+}
+
+function getDimensions( elem ) {
+	var raw = elem[0];
+	if ( raw.nodeType === 9 ) {
+		return {
+			width: elem.width(),
+			height: elem.height(),
+			offset: { top: 0, left: 0 }
+		};
+	}
+	if ( $.isWindow( raw ) ) {
+		return {
+			width: elem.width(),
+			height: elem.height(),
+			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
+		};
+	}
+	if ( raw.preventDefault ) {
+		return {
+			width: 0,
+			height: 0,
+			offset: { top: raw.pageY, left: raw.pageX }
+		};
+	}
+	return {
+		width: elem.outerWidth(),
+		height: elem.outerHeight(),
+		offset: elem.offset()
+	};
+}
+
+$.position = {
+	scrollbarWidth: function() {
+		if ( cachedScrollbarWidth !== undefined ) {
+			return cachedScrollbarWidth;
+		}
+		var w1, w2,
+			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
+			innerDiv = div.children()[0];
+
+		$( "body" ).append( div );
+		w1 = innerDiv.offsetWidth;
+		div.css( "overflow", "scroll" );
+
+		w2 = innerDiv.offsetWidth;
+
+		if ( w1 === w2 ) {
+			w2 = div[0].clientWidth;
+		}
+
+		div.remove();
+
+		return (cachedScrollbarWidth = w1 - w2);
+	},
+	getScrollInfo: function( within ) {
+		var overflowX = within.isWindow || within.isDocument ? "" :
+				within.element.css( "overflow-x" ),
+			overflowY = within.isWindow || within.isDocument ? "" :
+				within.element.css( "overflow-y" ),
+			hasOverflowX = overflowX === "scroll" ||
+				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
+			hasOverflowY = overflowY === "scroll" ||
+				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
+		return {
+			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
+			height: hasOverflowX ? $.position.scrollbarWidth() : 0
+		};
+	},
+	getWithinInfo: function( element ) {
+		var withinElement = $( element || window ),
+			isWindow = $.isWindow( withinElement[0] ),
+			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
+		return {
+			element: withinElement,
+			isWindow: isWindow,
+			isDocument: isDocument,
+			offset: withinElement.offset() || { left: 0, top: 0 },
+			scrollLeft: withinElement.scrollLeft(),
+			scrollTop: withinElement.scrollTop(),
+
+			// support: jQuery 1.6.x
+			// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
+			width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
+			height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
+		};
+	}
+};
+
+$.fn.position = function( options ) {
+	if ( !options || !options.of ) {
+		return _position.apply( this, arguments );
+	}
+
+	// make a copy, we don't want to modify arguments
+	options = $.extend( {}, options );
+
+	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
+		target = $( options.of ),
+		within = $.position.getWithinInfo( options.within ),
+		scrollInfo = $.position.getScrollInfo( within ),
+		collision = ( options.collision || "flip" ).split( " " ),
+		offsets = {};
+
+	dimensions = getDimensions( target );
+	if ( target[0].preventDefault ) {
+		// force left top to allow flipping
+		options.at = "left top";
+	}
+	targetWidth = dimensions.width;
+	targetHeight = dimensions.height;
+	targetOffset = dimensions.offset;
+	// clone to reuse original targetOffset later
+	basePosition = $.extend( {}, targetOffset );
+
+	// force my and at to have valid horizontal and vertical positions
+	// if a value is missing or invalid, it will be converted to center
+	$.each( [ "my", "at" ], function() {
+		var pos = ( options[ this ] || "" ).split( " " ),
+			horizontalOffset,
+			verticalOffset;
+
+		if ( pos.length === 1) {
+			pos = rhorizontal.test( pos[ 0 ] ) ?
+				pos.concat( [ "center" ] ) :
+				rvertical.test( pos[ 0 ] ) ?
+					[ "center" ].concat( pos ) :
+					[ "center", "center" ];
+		}
+		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
+		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
+
+		// calculate offsets
+		horizontalOffset = roffset.exec( pos[ 0 ] );
+		verticalOffset = roffset.exec( pos[ 1 ] );
+		offsets[ this ] = [
+			horizontalOffset ? horizontalOffset[ 0 ] : 0,
+			verticalOffset ? verticalOffset[ 0 ] : 0
+		];
+
+		// reduce to just the positions without the offsets
+		options[ this ] = [
+			rposition.exec( pos[ 0 ] )[ 0 ],
+			rposition.exec( pos[ 1 ] )[ 0 ]
+		];
+	});
+
+	// normalize collision option
+	if ( collision.length === 1 ) {
+		collision[ 1 ] = collision[ 0 ];
+	}
+
+	if ( options.at[ 0 ] === "right" ) {
+		basePosition.left += targetWidth;
+	} else if ( options.at[ 0 ] === "center" ) {
+		basePosition.left += targetWidth / 2;
+	}
+
+	if ( options.at[ 1 ] === "bottom" ) {
+		basePosition.top += targetHeight;
+	} else if ( options.at[ 1 ] === "center" ) {
+		basePosition.top += targetHeight / 2;
+	}
+
+	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
+	basePosition.left += atOffset[ 0 ];
+	basePosition.top += atOffset[ 1 ];
+
+	return this.each(function() {
+		var collisionPosition, using,
+			elem = $( this ),
+			elemWidth = elem.outerWidth(),
+			elemHeight = elem.outerHeight(),
+			marginLeft = parseCss( this, "marginLeft" ),
+			marginTop = parseCss( this, "marginTop" ),
+			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
+			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
+			position = $.extend( {}, basePosition ),
+			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
+
+		if ( options.my[ 0 ] === "right" ) {
+			position.left -= elemWidth;
+		} else if ( options.my[ 0 ] === "center" ) {
+			position.left -= elemWidth / 2;
+		}
+
+		if ( options.my[ 1 ] === "bottom" ) {
+			position.top -= elemHeight;
+		} else if ( options.my[ 1 ] === "center" ) {
+			position.top -= elemHeight / 2;
+		}
+
+		position.left += myOffset[ 0 ];
+		position.top += myOffset[ 1 ];
+
+		// if the browser doesn't support fractions, then round for consistent results
+		if ( !supportsOffsetFractions ) {
+			position.left = round( position.left );
+			position.top = round( position.top );
+		}
+
+		collisionPosition = {
+			marginLeft: marginLeft,
+			marginTop: marginTop
+		};
+
+		$.each( [ "left", "top" ], function( i, dir ) {
+			if ( $.ui.position[ collision[ i ] ] ) {
+				$.ui.position[ collision[ i ] ][ dir ]( position, {
+					targetWidth: targetWidth,
+					targetHeight: targetHeight,
+					elemWidth: elemWidth,
+					elemHeight: elemHeight,
+					collisionPosition: collisionPosition,
+					collisionWidth: collisionWidth,
+					collisionHeight: collisionHeight,
+					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
+					my: options.my,
+					at: options.at,
+					within: within,
+					elem: elem
+				});
+			}
+		});
+
+		if ( options.using ) {
+			// adds feedback as second argument to using callback, if present
+			using = function( props ) {
+				var left = targetOffset.left - position.left,
+					right = left + targetWidth - elemWidth,
+					top = targetOffset.top - position.top,
+					bottom = top + targetHeight - elemHeight,
+					feedback = {
+						target: {
+							element: target,
+							left: targetOffset.left,
+							top: targetOffset.top,
+							width: targetWidth,
+							height: targetHeight
+						},
+						element: {
+							element: elem,
+							left: position.left,
+							top: position.top,
+							width: elemWidth,
+							height: elemHeight
+						},
+						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
+						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
+					};
+				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
+					feedback.horizontal = "center";
+				}
+				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
+					feedback.vertical = "middle";
+				}
+				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
+					feedback.important = "horizontal";
+				} else {
+					feedback.important = "vertical";
+				}
+				options.using.call( this, props, feedback );
+			};
+		}
+
+		elem.offset( $.extend( position, { using: using } ) );
+	});
+};
+
+$.ui.position = {
+	fit: {
+		left: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
+				outerWidth = within.width,
+				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+				overLeft = withinOffset - collisionPosLeft,
+				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
+				newOverRight;
+
+			// element is wider than within
+			if ( data.collisionWidth > outerWidth ) {
+				// element is initially over the left side of within
+				if ( overLeft > 0 && overRight <= 0 ) {
+					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
+					position.left += overLeft - newOverRight;
+				// element is initially over right side of within
+				} else if ( overRight > 0 && overLeft <= 0 ) {
+					position.left = withinOffset;
+				// element is initially over both left and right sides of within
+				} else {
+					if ( overLeft > overRight ) {
+						position.left = withinOffset + outerWidth - data.collisionWidth;
+					} else {
+						position.left = withinOffset;
+					}
+				}
+			// too far left -> align with left edge
+			} else if ( overLeft > 0 ) {
+				position.left += overLeft;
+			// too far right -> align with right edge
+			} else if ( overRight > 0 ) {
+				position.left -= overRight;
+			// adjust based on position and margin
+			} else {
+				position.left = max( position.left - collisionPosLeft, position.left );
+			}
+		},
+		top: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
+				outerHeight = data.within.height,
+				collisionPosTop = position.top - data.collisionPosition.marginTop,
+				overTop = withinOffset - collisionPosTop,
+				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
+				newOverBottom;
+
+			// element is taller than within
+			if ( data.collisionHeight > outerHeight ) {
+				// element is initially over the top of within
+				if ( overTop > 0 && overBottom <= 0 ) {
+					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
+					position.top += overTop - newOverBottom;
+				// element is initially over bottom of within
+				} else if ( overBottom > 0 && overTop <= 0 ) {
+					position.top = withinOffset;
+				// element is initially over both top and bottom of within
+				} else {
+					if ( overTop > overBottom ) {
+						position.top = withinOffset + outerHeight - data.collisionHeight;
+					} else {
+						position.top = withinOffset;
+					}
+				}
+			// too far up -> align with top
+			} else if ( overTop > 0 ) {
+				position.top += overTop;
+			// too far down -> align with bottom edge
+			} else if ( overBottom > 0 ) {
+				position.top -= overBottom;
+			// adjust based on position and margin
+			} else {
+				position.top = max( position.top - collisionPosTop, position.top );
+			}
+		}
+	},
+	flip: {
+		left: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.offset.left + within.scrollLeft,
+				outerWidth = within.width,
+				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
+				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+				overLeft = collisionPosLeft - offsetLeft,
+				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
+				myOffset = data.my[ 0 ] === "left" ?
+					-data.elemWidth :
+					data.my[ 0 ] === "right" ?
+						data.elemWidth :
+						0,
+				atOffset = data.at[ 0 ] === "left" ?
+					data.targetWidth :
+					data.at[ 0 ] === "right" ?
+						-data.targetWidth :
+						0,
+				offset = -2 * data.offset[ 0 ],
+				newOverRight,
+				newOverLeft;
+
+			if ( overLeft < 0 ) {
+				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
+				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
+					position.left += myOffset + atOffset + offset;
+				}
+			} else if ( overRight > 0 ) {
+				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
+				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
+					position.left += myOffset + atOffset + offset;
+				}
+			}
+		},
+		top: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.offset.top + within.scrollTop,
+				outerHeight = within.height,
+				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
+				collisionPosTop = position.top - data.collisionPosition.marginTop,
+				overTop = collisionPosTop - offsetTop,
+				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
+				top = data.my[ 1 ] === "top",
+				myOffset = top ?
+					-data.elemHeight :
+					data.my[ 1 ] === "bottom" ?
+						data.elemHeight :
+						0,
+				atOffset = data.at[ 1 ] === "top" ?
+					data.targetHeight :
+					data.at[ 1 ] === "bottom" ?
+						-data.targetHeight :
+						0,
+				offset = -2 * data.offset[ 1 ],
+				newOverTop,
+				newOverBottom;
+			if ( overTop < 0 ) {
+				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
+				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
+					position.top += myOffset + atOffset + offset;
+				}
+			} else if ( overBottom > 0 ) {
+				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
+				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
+					position.top += myOffset + atOffset + offset;
+				}
+			}
+		}
+	},
+	flipfit: {
+		left: function() {
+			$.ui.position.flip.left.apply( this, arguments );
+			$.ui.position.fit.left.apply( this, arguments );
+		},
+		top: function() {
+			$.ui.position.flip.top.apply( this, arguments );
+			$.ui.position.fit.top.apply( this, arguments );
+		}
+	}
+};
+
+// fraction support test
+(function() {
+	var testElement, testElementParent, testElementStyle, offsetLeft, i,
+		body = document.getElementsByTagName( "body" )[ 0 ],
+		div = document.createElement( "div" );
+
+	//Create a "fake body" for testing based on method used in jQuery.support
+	testElement = document.createElement( body ? "div" : "body" );
+	testElementStyle = {
+		visibility: "hidden",
+		width: 0,
+		height: 0,
+		border: 0,
+		margin: 0,
+		background: "none"
+	};
+	if ( body ) {
+		$.extend( testElementStyle, {
+			position: "absolute",
+			left: "-1000px",
+			top: "-1000px"
+		});
+	}
+	for ( i in testElementStyle ) {
+		testElement.style[ i ] = testElementStyle[ i ];
+	}
+	testElement.appendChild( div );
+	testElementParent = body || document.documentElement;
+	testElementParent.insertBefore( testElement, testElementParent.firstChild );
+
+	div.style.cssText = "position: absolute; left: 10.7432222px;";
+
+	offsetLeft = $( div ).offset().left;
+	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
+
+	testElement.innerHTML = "";
+	testElementParent.removeChild( testElement );
+})();
+
+})();
+
+var position = $.ui.position;
+
+
 /*!
  * jQuery UI Sortable 1.11.4
  * http://jqueryui.com
@@ -2918,5 +3425,1248 @@ var accordion = $.widget( "ui.accordion", {
 });
 
 
+/*!
+ * jQuery UI Menu 1.11.4
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/menu/
+ */
+
+
+var menu = $.widget( "ui.menu", {
+	version: "1.11.4",
+	defaultElement: "<ul>",
+	delay: 300,
+	options: {
+		icons: {
+			submenu: "ui-icon-carat-1-e"
+		},
+		items: "> *",
+		menus: "ul",
+		position: {
+			my: "left-1 top",
+			at: "right top"
+		},
+		role: "menu",
+
+		// callbacks
+		blur: null,
+		focus: null,
+		select: null
+	},
+
+	_create: function() {
+		this.activeMenu = this.element;
+
+		// Flag used to prevent firing of the click handler
+		// as the event bubbles up through nested menus
+		this.mouseHandled = false;
+		this.element
+			.uniqueId()
+			.addClass( "ui-menu ui-widget ui-widget-content" )
+			.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
+			.attr({
+				role: this.options.role,
+				tabIndex: 0
+			});
+
+		if ( this.options.disabled ) {
+			this.element
+				.addClass( "ui-state-disabled" )
+				.attr( "aria-disabled", "true" );
+		}
+
+		this._on({
+			// Prevent focus from sticking to links inside menu after clicking
+			// them (focus should always stay on UL during navigation).
+			"mousedown .ui-menu-item": function( event ) {
+				event.preventDefault();
+			},
+			"click .ui-menu-item": function( event ) {
+				var target = $( event.target );
+				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
+					this.select( event );
+
+					// Only set the mouseHandled flag if the event will bubble, see #9469.
+					if ( !event.isPropagationStopped() ) {
+						this.mouseHandled = true;
+					}
+
+					// Open submenu on click
+					if ( target.has( ".ui-menu" ).length ) {
+						this.expand( event );
+					} else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
+
+						// Redirect focus to the menu
+						this.element.trigger( "focus", [ true ] );
+
+						// If the active item is on the top level, let it stay active.
+						// Otherwise, blur the active item since it is no longer visible.
+						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
+							clearTimeout( this.timer );
+						}
+					}
+				}
+			},
+			"mouseenter .ui-menu-item": function( event ) {
+				// Ignore mouse events while typeahead is active, see #10458.
+				// Prevents focusing the wrong item when typeahead causes a scroll while the mouse
+				// is over an item in the menu
+				if ( this.previousFilter ) {
+					return;
+				}
+				var target = $( event.currentTarget );
+				// Remove ui-state-active class from siblings of the newly focused menu item
+				// to avoid a jump caused by adjacent elements both having a class with a border
+				target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
+				this.focus( event, target );
+			},
+			mouseleave: "collapseAll",
+			"mouseleave .ui-menu": "collapseAll",
+			focus: function( event, keepActiveItem ) {
+				// If there's already an active item, keep it active
+				// If not, activate the first item
+				var item = this.active || this.element.find( this.options.items ).eq( 0 );
+
+				if ( !keepActiveItem ) {
+					this.focus( event, item );
+				}
+			},
+			blur: function( event ) {
+				this._delay(function() {
+					if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
+						this.collapseAll( event );
+					}
+				});
+			},
+			keydown: "_keydown"
+		});
+
+		this.refresh();
+
+		// Clicks outside of a menu collapse any open menus
+		this._on( this.document, {
+			click: function( event ) {
+				if ( this._closeOnDocumentClick( event ) ) {
+					this.collapseAll( event );
+				}
+
+				// Reset the mouseHandled flag
+				this.mouseHandled = false;
+			}
+		});
+	},
+
+	_destroy: function() {
+		// Destroy (sub)menus
+		this.element
+			.removeAttr( "aria-activedescendant" )
+			.find( ".ui-menu" ).addBack()
+				.removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
+				.removeAttr( "role" )
+				.removeAttr( "tabIndex" )
+				.removeAttr( "aria-labelledby" )
+				.removeAttr( "aria-expanded" )
+				.removeAttr( "aria-hidden" )
+				.removeAttr( "aria-disabled" )
+				.removeUniqueId()
+				.show();
+
+		// Destroy menu items
+		this.element.find( ".ui-menu-item" )
+			.removeClass( "ui-menu-item" )
+			.removeAttr( "role" )
+			.removeAttr( "aria-disabled" )
+			.removeUniqueId()
+			.removeClass( "ui-state-hover" )
+			.removeAttr( "tabIndex" )
+			.removeAttr( "role" )
+			.removeAttr( "aria-haspopup" )
+			.children().each( function() {
+				var elem = $( this );
+				if ( elem.data( "ui-menu-submenu-carat" ) ) {
+					elem.remove();
+				}
+			});
+
+		// Destroy menu dividers
+		this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
+	},
+
+	_keydown: function( event ) {
+		var match, prev, character, skip,
+			preventDefault = true;
+
+		switch ( event.keyCode ) {
+		case $.ui.keyCode.PAGE_UP:
+			this.previousPage( event );
+			break;
+		case $.ui.keyCode.PAGE_DOWN:
+			this.nextPage( event );
+			break;
+		case $.ui.keyCode.HOME:
+			this._move( "first", "first", event );
+			break;
+		case $.ui.keyCode.END:
+			this._move( "last", "last", event );
+			break;
+		case $.ui.keyCode.UP:
+			this.previous( event );
+			break;
+		case $.ui.keyCode.DOWN:
+			this.next( event );
+			break;
+		case $.ui.keyCode.LEFT:
+			this.collapse( event );
+			break;
+		case $.ui.keyCode.RIGHT:
+			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
+				this.expand( event );
+			}
+			break;
+		case $.ui.keyCode.ENTER:
+		case $.ui.keyCode.SPACE:
+			this._activate( event );
+			break;
+		case $.ui.keyCode.ESCAPE:
+			this.collapse( event );
+			break;
+		default:
+			preventDefault = false;
+			prev = this.previousFilter || "";
+			character = String.fromCharCode( event.keyCode );
+			skip = false;
+
+			clearTimeout( this.filterTimer );
+
+			if ( character === prev ) {
+				skip = true;
+			} else {
+				character = prev + character;
+			}
+
+			match = this._filterMenuItems( character );
+			match = skip && match.index( this.active.next() ) !== -1 ?
+				this.active.nextAll( ".ui-menu-item" ) :
+				match;
+
+			// If no matches on the current filter, reset to the last character pressed
+			// to move down the menu to the first item that starts with that character
+			if ( !match.length ) {
+				character = String.fromCharCode( event.keyCode );
+				match = this._filterMenuItems( character );
+			}
+
+			if ( match.length ) {
+				this.focus( event, match );
+				this.previousFilter = character;
+				this.filterTimer = this._delay(function() {
+					delete this.previousFilter;
+				}, 1000 );
+			} else {
+				delete this.previousFilter;
+			}
+		}
+
+		if ( preventDefault ) {
+			event.preventDefault();
+		}
+	},
+
+	_activate: function( event ) {
+		if ( !this.active.is( ".ui-state-disabled" ) ) {
+			if ( this.active.is( "[aria-haspopup='true']" ) ) {
+				this.expand( event );
+			} else {
+				this.select( event );
+			}
+		}
+	},
+
+	refresh: function() {
+		var menus, items,
+			that = this,
+			icon = this.options.icons.submenu,
+			submenus = this.element.find( this.options.menus );
+
+		this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
+
+		// Initialize nested menus
+		submenus.filter( ":not(.ui-menu)" )
+			.addClass( "ui-menu ui-widget ui-widget-content ui-front" )
+			.hide()
+			.attr({
+				role: this.options.role,
+				"aria-hidden": "true",
+				"aria-expanded": "false"
+			})
+			.each(function() {
+				var menu = $( this ),
+					item = menu.parent(),
+					submenuCarat = $( "<span>" )
+						.addClass( "ui-menu-icon ui-icon " + icon )
+						.data( "ui-menu-submenu-carat", true );
+
+				item
+					.attr( "aria-haspopup", "true" )
+					.prepend( submenuCarat );
+				menu.attr( "aria-labelledby", item.attr( "id" ) );
+			});
+
+		menus = submenus.add( this.element );
+		items = menus.find( this.options.items );
+
+		// Initialize menu-items containing spaces and/or dashes only as dividers
+		items.not( ".ui-menu-item" ).each(function() {
+			var item = $( this );
+			if ( that._isDivider( item ) ) {
+				item.addClass( "ui-widget-content ui-menu-divider" );
+			}
+		});
+
+		// Don't refresh list items that are already adapted
+		items.not( ".ui-menu-item, .ui-menu-divider" )
+			.addClass( "ui-menu-item" )
+			.uniqueId()
+			.attr({
+				tabIndex: -1,
+				role: this._itemRole()
+			});
+
+		// Add aria-disabled attribute to any disabled menu item
+		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
+
+		// If the active item has been removed, blur the menu
+		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
+			this.blur();
+		}
+	},
+
+	_itemRole: function() {
+		return {
+			menu: "menuitem",
+			listbox: "option"
+		}[ this.options.role ];
+	},
+
+	_setOption: function( key, value ) {
+		if ( key === "icons" ) {
+			this.element.find( ".ui-menu-icon" )
+				.removeClass( this.options.icons.submenu )
+				.addClass( value.submenu );
+		}
+		if ( key === "disabled" ) {
+			this.element
+				.toggleClass( "ui-state-disabled", !!value )
+				.attr( "aria-disabled", value );
+		}
+		this._super( key, value );
+	},
+
+	focus: function( event, item ) {
+		var nested, focused;
+		this.blur( event, event && event.type === "focus" );
+
+		this._scrollIntoView( item );
+
+		this.active = item.first();
+		focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
+		// Only update aria-activedescendant if there's a role
+		// otherwise we assume focus is managed elsewhere
+		if ( this.options.role ) {
+			this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
+		}
+
+		// Highlight active parent menu item, if any
+		this.active
+			.parent()
+			.closest( ".ui-menu-item" )
+			.addClass( "ui-state-active" );
+
+		if ( event && event.type === "keydown" ) {
+			this._close();
+		} else {
+			this.timer = this._delay(function() {
+				this._close();
+			}, this.delay );
+		}
+
+		nested = item.children( ".ui-menu" );
+		if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
+			this._startOpening(nested);
+		}
+		this.activeMenu = item.parent();
+
+		this._trigger( "focus", event, { item: item } );
+	},
+
+	_scrollIntoView: function( item ) {
+		var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
+		if ( this._hasScroll() ) {
+			borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
+			paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
+			offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
+			scroll = this.activeMenu.scrollTop();
+			elementHeight = this.activeMenu.height();
+			itemHeight = item.outerHeight();
+
+			if ( offset < 0 ) {
+				this.activeMenu.scrollTop( scroll + offset );
+			} else if ( offset + itemHeight > elementHeight ) {
+				this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
+			}
+		}
+	},
+
+	blur: function( event, fromFocus ) {
+		if ( !fromFocus ) {
+			clearTimeout( this.timer );
+		}
+
+		if ( !this.active ) {
+			return;
+		}
+
+		this.active.removeClass( "ui-state-focus" );
+		this.active = null;
+
+		this._trigger( "blur", event, { item: this.active } );
+	},
+
+	_startOpening: function( submenu ) {
+		clearTimeout( this.timer );
+
+		// Don't open if already open fixes a Firefox bug that caused a .5 pixel
+		// shift in the submenu position when mousing over the carat icon
+		if ( submenu.attr( "aria-hidden" ) !== "true" ) {
+			return;
+		}
+
+		this.timer = this._delay(function() {
+			this._close();
+			this._open( submenu );
+		}, this.delay );
+	},
+
+	_open: function( submenu ) {
+		var position = $.extend({
+			of: this.active
+		}, this.options.position );
+
+		clearTimeout( this.timer );
+		this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
+			.hide()
+			.attr( "aria-hidden", "true" );
+
+		submenu
+			.show()
+			.removeAttr( "aria-hidden" )
+			.attr( "aria-expanded", "true" )
+			.position( position );
+	},
+
+	collapseAll: function( event, all ) {
+		clearTimeout( this.timer );
+		this.timer = this._delay(function() {
+			// If we were passed an event, look for the submenu that contains the event
+			var currentMenu = all ? this.element :
+				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
+
+			// If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
+			if ( !currentMenu.length ) {
+				currentMenu = this.element;
+			}
+
+			this._close( currentMenu );
+
+			this.blur( event );
+			this.activeMenu = currentMenu;
+		}, this.delay );
+	},
+
+	// With no arguments, closes the currently active menu - if nothing is active
+	// it closes all menus.  If passed an argument, it will search for menus BELOW
+	_close: function( startMenu ) {
+		if ( !startMenu ) {
+			startMenu = this.active ? this.active.parent() : this.element;
+		}
+
+		startMenu
+			.find( ".ui-menu" )
+				.hide()
+				.attr( "aria-hidden", "true" )
+				.attr( "aria-expanded", "false" )
+			.end()
+			.find( ".ui-state-active" ).not( ".ui-state-focus" )
+				.removeClass( "ui-state-active" );
+	},
+
+	_closeOnDocumentClick: function( event ) {
+		return !$( event.target ).closest( ".ui-menu" ).length;
+	},
+
+	_isDivider: function( item ) {
+
+		// Match hyphen, em dash, en dash
+		return !/[^\-\u2014\u2013\s]/.test( item.text() );
+	},
+
+	collapse: function( event ) {
+		var newItem = this.active &&
+			this.active.parent().closest( ".ui-menu-item", this.element );
+		if ( newItem && newItem.length ) {
+			this._close();
+			this.focus( event, newItem );
+		}
+	},
+
+	expand: function( event ) {
+		var newItem = this.active &&
+			this.active
+				.children( ".ui-menu " )
+				.find( this.options.items )
+				.first();
+
+		if ( newItem && newItem.length ) {
+			this._open( newItem.parent() );
+
+			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
+			this._delay(function() {
+				this.focus( event, newItem );
+			});
+		}
+	},
+
+	next: function( event ) {
+		this._move( "next", "first", event );
+	},
+
+	previous: function( event ) {
+		this._move( "prev", "last", event );
+	},
+
+	isFirstItem: function() {
+		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
+	},
+
+	isLastItem: function() {
+		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
+	},
+
+	_move: function( direction, filter, event ) {
+		var next;
+		if ( this.active ) {
+			if ( direction === "first" || direction === "last" ) {
+				next = this.active
+					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
+					.eq( -1 );
+			} else {
+				next = this.active
+					[ direction + "All" ]( ".ui-menu-item" )
+					.eq( 0 );
+			}
+		}
+		if ( !next || !next.length || !this.active ) {
+			next = this.activeMenu.find( this.options.items )[ filter ]();
+		}
+
+		this.focus( event, next );
+	},
+
+	nextPage: function( event ) {
+		var item, base, height;
+
+		if ( !this.active ) {
+			this.next( event );
+			return;
+		}
+		if ( this.isLastItem() ) {
+			return;
+		}
+		if ( this._hasScroll() ) {
+			base = this.active.offset().top;
+			height = this.element.height();
+			this.active.nextAll( ".ui-menu-item" ).each(function() {
+				item = $( this );
+				return item.offset().top - base - height < 0;
+			});
+
+			this.focus( event, item );
+		} else {
+			this.focus( event, this.activeMenu.find( this.options.items )
+				[ !this.active ? "first" : "last" ]() );
+		}
+	},
+
+	previousPage: function( event ) {
+		var item, base, height;
+		if ( !this.active ) {
+			this.next( event );
+			return;
+		}
+		if ( this.isFirstItem() ) {
+			return;
+		}
+		if ( this._hasScroll() ) {
+			base = this.active.offset().top;
+			height = this.element.height();
+			this.active.prevAll( ".ui-menu-item" ).each(function() {
+				item = $( this );
+				return item.offset().top - base + height > 0;
+			});
+
+			this.focus( event, item );
+		} else {
+			this.focus( event, this.activeMenu.find( this.options.items ).first() );
+		}
+	},
+
+	_hasScroll: function() {
+		return this.element.outerHeight() < this.element.prop( "scrollHeight" );
+	},
+
+	select: function( event ) {
+		// TODO: It should never be possible to not have an active item at this
+		// point, but the tests don't trigger mouseenter before click.
+		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
+		var ui = { item: this.active };
+		if ( !this.active.has( ".ui-menu" ).length ) {
+			this.collapseAll( event, true );
+		}
+		this._trigger( "select", event, ui );
+	},
+
+	_filterMenuItems: function(character) {
+		var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
+			regex = new RegExp( "^" + escapedCharacter, "i" );
+
+		return this.activeMenu
+			.find( this.options.items )
+
+			// Only match on items, not dividers or other content (#10571)
+			.filter( ".ui-menu-item" )
+			.filter(function() {
+				return regex.test( $.trim( $( this ).text() ) );
+			});
+	}
+});
+
+
+/*!
+ * jQuery UI Autocomplete 1.11.4
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/autocomplete/
+ */
+
+
+$.widget( "ui.autocomplete", {
+	version: "1.11.4",
+	defaultElement: "<input>",
+	options: {
+		appendTo: null,
+		autoFocus: false,
+		delay: 300,
+		minLength: 1,
+		position: {
+			my: "left top",
+			at: "left bottom",
+			collision: "none"
+		},
+		source: null,
+
+		// callbacks
+		change: null,
+		close: null,
+		focus: null,
+		open: null,
+		response: null,
+		search: null,
+		select: null
+	},
+
+	requestIndex: 0,
+	pending: 0,
+
+	_create: function() {
+		// Some browsers only repeat keydown events, not keypress events,
+		// so we use the suppressKeyPress flag to determine if we've already
+		// handled the keydown event. #7269
+		// Unfortunately the code for & in keypress is the same as the up arrow,
+		// so we use the suppressKeyPressRepeat flag to avoid handling keypress
+		// events when we know the keydown event was used to modify the
+		// search term. #7799
+		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
+			nodeName = this.element[ 0 ].nodeName.toLowerCase(),
+			isTextarea = nodeName === "textarea",
+			isInput = nodeName === "input";
+
+		this.isMultiLine =
+			// Textareas are always multi-line
+			isTextarea ? true :
+			// Inputs are always single-line, even if inside a contentEditable element
+			// IE also treats inputs as contentEditable
+			isInput ? false :
+			// All other element types are determined by whether or not they're contentEditable
+			this.element.prop( "isContentEditable" );
+
+		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
+		this.isNewMenu = true;
+
+		this.element
+			.addClass( "ui-autocomplete-input" )
+			.attr( "autocomplete", "off" );
+
+		this._on( this.element, {
+			keydown: function( event ) {
+				if ( this.element.prop( "readOnly" ) ) {
+					suppressKeyPress = true;
+					suppressInput = true;
+					suppressKeyPressRepeat = true;
+					return;
+				}
+
+				suppressKeyPress = false;
+				suppressInput = false;
+				suppressKeyPressRepeat = false;
+				var keyCode = $.ui.keyCode;
+				switch ( event.keyCode ) {
+				case keyCode.PAGE_UP:
+					suppressKeyPress = true;
+					this._move( "previousPage", event );
+					break;
+				case keyCode.PAGE_DOWN:
+					suppressKeyPress = true;
+					this._move( "nextPage", event );
+					break;
+				case keyCode.UP:
+					suppressKeyPress = true;
+					this._keyEvent( "previous", event );
+					break;
+				case keyCode.DOWN:
+					suppressKeyPress = true;
+					this._keyEvent( "next", event );
+					break;
+				case keyCode.ENTER:
+					// when menu is open and has focus
+					if ( this.menu.active ) {
+						// #6055 - Opera still allows the keypress to occur
+						// which causes forms to submit
+						suppressKeyPress = true;
+						event.preventDefault();
+						this.menu.select( event );
+					}
+					break;
+				case keyCode.TAB:
+					if ( this.menu.active ) {
+						this.menu.select( event );
+					}
+					break;
+				case keyCode.ESCAPE:
+					if ( this.menu.element.is( ":visible" ) ) {
+						if ( !this.isMultiLine ) {
+							this._value( this.term );
+						}
+						this.close( event );
+						// Different browsers have different default behavior for escape
+						// Single press can mean undo or clear
+						// Double press in IE means clear the whole form
+						event.preventDefault();
+					}
+					break;
+				default:
+					suppressKeyPressRepeat = true;
+					// search timeout should be triggered before the input value is changed
+					this._searchTimeout( event );
+					break;
+				}
+			},
+			keypress: function( event ) {
+				if ( suppressKeyPress ) {
+					suppressKeyPress = false;
+					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
+						event.preventDefault();
+					}
+					return;
+				}
+				if ( suppressKeyPressRepeat ) {
+					return;
+				}
+
+				// replicate some key handlers to allow them to repeat in Firefox and Opera
+				var keyCode = $.ui.keyCode;
+				switch ( event.keyCode ) {
+				case keyCode.PAGE_UP:
+					this._move( "previousPage", event );
+					break;
+				case keyCode.PAGE_DOWN:
+					this._move( "nextPage", event );
+					break;
+				case keyCode.UP:
+					this._keyEvent( "previous", event );
+					break;
+				case keyCode.DOWN:
+					this._keyEvent( "next", event );
+					break;
+				}
+			},
+			input: function( event ) {
+				if ( suppressInput ) {
+					suppressInput = false;
+					event.preventDefault();
+					return;
+				}
+				this._searchTimeout( event );
+			},
+			focus: function() {
+				this.selectedItem = null;
+				this.previous = this._value();
+			},
+			blur: function( event ) {
+				if ( this.cancelBlur ) {
+					delete this.cancelBlur;
+					return;
+				}
+
+				clearTimeout( this.searching );
+				this.close( event );
+				this._change( event );
+			}
+		});
+
+		this._initSource();
+		this.menu = $( "<ul>" )
+			.addClass( "ui-autocomplete ui-front" )
+			.appendTo( this._appendTo() )
+			.menu({
+				// disable ARIA support, the live region takes care of that
+				role: null
+			})
+			.hide()
+			.menu( "instance" );
+
+		this._on( this.menu.element, {
+			mousedown: function( event ) {
+				// prevent moving focus out of the text field
+				event.preventDefault();
+
+				// IE doesn't prevent moving focus even with event.preventDefault()
+				// so we set a flag to know when we should ignore the blur event
+				this.cancelBlur = true;
+				this._delay(function() {
+					delete this.cancelBlur;
+				});
+
+				// clicking on the scrollbar causes focus to shift to the body
+				// but we can't detect a mouseup or a click immediately afterward
+				// so we have to track the next mousedown and close the menu if
+				// the user clicks somewhere outside of the autocomplete
+				var menuElement = this.menu.element[ 0 ];
+				if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
+					this._delay(function() {
+						var that = this;
+						this.document.one( "mousedown", function( event ) {
+							if ( event.target !== that.element[ 0 ] &&
+									event.target !== menuElement &&
+									!$.contains( menuElement, event.target ) ) {
+								that.close();
+							}
+						});
+					});
+				}
+			},
+			menufocus: function( event, ui ) {
+				var label, item;
+				// support: Firefox
+				// Prevent accidental activation of menu items in Firefox (#7024 #9118)
+				if ( this.isNewMenu ) {
+					this.isNewMenu = false;
+					if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
+						this.menu.blur();
+
+						this.document.one( "mousemove", function() {
+							$( event.target ).trigger( event.originalEvent );
+						});
+
+						return;
+					}
+				}
+
+				item = ui.item.data( "ui-autocomplete-item" );
+				if ( false !== this._trigger( "focus", event, { item: item } ) ) {
+					// use value to match what will end up in the input, if it was a key event
+					if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
+						this._value( item.value );
+					}
+				}
+
+				// Announce the value in the liveRegion
+				label = ui.item.attr( "aria-label" ) || item.value;
+				if ( label && $.trim( label ).length ) {
+					this.liveRegion.children().hide();
+					$( "<div>" ).text( label ).appendTo( this.liveRegion );
+				}
+			},
+			menuselect: function( event, ui ) {
+				var item = ui.item.data( "ui-autocomplete-item" ),
+					previous = this.previous;
+
+				// only trigger when focus was lost (click on menu)
+				if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
+					this.element.focus();
+					this.previous = previous;
+					// #6109 - IE triggers two focus events and the second
+					// is asynchronous, so we need to reset the previous
+					// term synchronously and asynchronously :-(
+					this._delay(function() {
+						this.previous = previous;
+						this.selectedItem = item;
+					});
+				}
+
+				if ( false !== this._trigger( "select", event, { item: item } ) ) {
+					this._value( item.value );
+				}
+				// reset the term after the select event
+				// this allows custom select handling to work properly
+				this.term = this._value();
+
+				this.close( event );
+				this.selectedItem = item;
+			}
+		});
+
+		this.liveRegion = $( "<span>", {
+				role: "status",
+				"aria-live": "assertive",
+				"aria-relevant": "additions"
+			})
+			.addClass( "ui-helper-hidden-accessible" )
+			.appendTo( this.document[ 0 ].body );
+
+		// turning off autocomplete prevents the browser from remembering the
+		// value when navigating through history, so we re-enable autocomplete
+		// if the page is unloaded before the widget is destroyed. #7790
+		this._on( this.window, {
+			beforeunload: function() {
+				this.element.removeAttr( "autocomplete" );
+			}
+		});
+	},
+
+	_destroy: function() {
+		clearTimeout( this.searching );
+		this.element
+			.removeClass( "ui-autocomplete-input" )
+			.removeAttr( "autocomplete" );
+		this.menu.element.remove();
+		this.liveRegion.remove();
+	},
+
+	_setOption: function( key, value ) {
+		this._super( key, value );
+		if ( key === "source" ) {
+			this._initSource();
+		}
+		if ( key === "appendTo" ) {
+			this.menu.element.appendTo( this._appendTo() );
+		}
+		if ( key === "disabled" && value && this.xhr ) {
+			this.xhr.abort();
+		}
+	},
+
+	_appendTo: function() {
+		var element = this.options.appendTo;
+
+		if ( element ) {
+			element = element.jquery || element.nodeType ?
+				$( element ) :
+				this.document.find( element ).eq( 0 );
+		}
+
+		if ( !element || !element[ 0 ] ) {
+			element = this.element.closest( ".ui-front" );
+		}
+
+		if ( !element.length ) {
+			element = this.document[ 0 ].body;
+		}
+
+		return element;
+	},
+
+	_initSource: function() {
+		var array, url,
+			that = this;
+		if ( $.isArray( this.options.source ) ) {
+			array = this.options.source;
+			this.source = function( request, response ) {
+				response( $.ui.autocomplete.filter( array, request.term ) );
+			};
+		} else if ( typeof this.options.source === "string" ) {
+			url = this.options.source;
+			this.source = function( request, response ) {
+				if ( that.xhr ) {
+					that.xhr.abort();
+				}
+				that.xhr = $.ajax({
+					url: url,
+					data: request,
+					dataType: "json",
+					success: function( data ) {
+						response( data );
+					},
+					error: function() {
+						response([]);
+					}
+				});
+			};
+		} else {
+			this.source = this.options.source;
+		}
+	},
+
+	_searchTimeout: function( event ) {
+		clearTimeout( this.searching );
+		this.searching = this._delay(function() {
+
+			// Search if the value has changed, or if the user retypes the same value (see #7434)
+			var equalValues = this.term === this._value(),
+				menuVisible = this.menu.element.is( ":visible" ),
+				modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
+
+			if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
+				this.selectedItem = null;
+				this.search( null, event );
+			}
+		}, this.options.delay );
+	},
+
+	search: function( value, event ) {
+		value = value != null ? value : this._value();
+
+		// always save the actual value, not the one passed as an argument
+		this.term = this._value();
+
+		if ( value.length < this.options.minLength ) {
+			return this.close( event );
+		}
+
+		if ( this._trigger( "search", event ) === false ) {
+			return;
+		}
+
+		return this._search( value );
+	},
+
+	_search: function( value ) {
+		this.pending++;
+		this.element.addClass( "ui-autocomplete-loading" );
+		this.cancelSearch = false;
+
+		this.source( { term: value }, this._response() );
+	},
+
+	_response: function() {
+		var index = ++this.requestIndex;
+
+		return $.proxy(function( content ) {
+			if ( index === this.requestIndex ) {
+				this.__response( content );
+			}
+
+			this.pending--;
+			if ( !this.pending ) {
+				this.element.removeClass( "ui-autocomplete-loading" );
+			}
+		}, this );
+	},
+
+	__response: function( content ) {
+		if ( content ) {
+			content = this._normalize( content );
+		}
+		this._trigger( "response", null, { content: content } );
+		if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
+			this._suggest( content );
+			this._trigger( "open" );
+		} else {
+			// use ._close() instead of .close() so we don't cancel future searches
+			this._close();
+		}
+	},
+
+	close: function( event ) {
+		this.cancelSearch = true;
+		this._close( event );
+	},
+
+	_close: function( event ) {
+		if ( this.menu.element.is( ":visible" ) ) {
+			this.menu.element.hide();
+			this.menu.blur();
+			this.isNewMenu = true;
+			this._trigger( "close", event );
+		}
+	},
+
+	_change: function( event ) {
+		if ( this.previous !== this._value() ) {
+			this._trigger( "change", event, { item: this.selectedItem } );
+		}
+	},
+
+	_normalize: function( items ) {
+		// assume all items have the right format when the first item is complete
+		if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
+			return items;
+		}
+		return $.map( items, function( item ) {
+			if ( typeof item === "string" ) {
+				return {
+					label: item,
+					value: item
+				};
+			}
+			return $.extend( {}, item, {
+				label: item.label || item.value,
+				value: item.value || item.label
+			});
+		});
+	},
+
+	_suggest: function( items ) {
+		var ul = this.menu.element.empty();
+		this._renderMenu( ul, items );
+		this.isNewMenu = true;
+		this.menu.refresh();
+
+		// size and position menu
+		ul.show();
+		this._resizeMenu();
+		ul.position( $.extend({
+			of: this.element
+		}, this.options.position ) );
+
+		if ( this.options.autoFocus ) {
+			this.menu.next();
+		}
+	},
+
+	_resizeMenu: function() {
+		var ul = this.menu.element;
+		ul.outerWidth( Math.max(
+			// Firefox wraps long text (possibly a rounding bug)
+			// so we add 1px to avoid the wrapping (#7513)
+			ul.width( "" ).outerWidth() + 1,
+			this.element.outerWidth()
+		) );
+	},
+
+	_renderMenu: function( ul, items ) {
+		var that = this;
+		$.each( items, function( index, item ) {
+			that._renderItemData( ul, item );
+		});
+	},
+
+	_renderItemData: function( ul, item ) {
+		return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
+	},
+
+	_renderItem: function( ul, item ) {
+		return $( "<li>" ).text( item.label ).appendTo( ul );
+	},
+
+	_move: function( direction, event ) {
+		if ( !this.menu.element.is( ":visible" ) ) {
+			this.search( null, event );
+			return;
+		}
+		if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
+				this.menu.isLastItem() && /^next/.test( direction ) ) {
+
+			if ( !this.isMultiLine ) {
+				this._value( this.term );
+			}
+
+			this.menu.blur();
+			return;
+		}
+		this.menu[ direction ]( event );
+	},
+
+	widget: function() {
+		return this.menu.element;
+	},
+
+	_value: function() {
+		return this.valueMethod.apply( this.element, arguments );
+	},
+
+	_keyEvent: function( keyEvent, event ) {
+		if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
+			this._move( keyEvent, event );
+
+			// prevents moving cursor to beginning/end of the text field in some browsers
+			event.preventDefault();
+		}
+	}
+});
+
+$.extend( $.ui.autocomplete, {
+	escapeRegex: function( value ) {
+		return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
+	},
+	filter: function( array, term ) {
+		var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
+		return $.grep( array, function( value ) {
+			return matcher.test( value.label || value.value || value );
+		});
+	}
+});
+
+// live region extension, adding a `messages` option
+// NOTE: This is an experimental API. We are still investigating
+// a full solution for string manipulation and internationalization.
+$.widget( "ui.autocomplete", $.ui.autocomplete, {
+	options: {
+		messages: {
+			noResults: "No search results.",
+			results: function( amount ) {
+				return amount + ( amount > 1 ? " results are" : " result is" ) +
+					" available, use up and down arrow keys to navigate.";
+			}
+		}
+	},
+
+	__response: function( content ) {
+		var message;
+		this._superApply( arguments );
+		if ( this.options.disabled || this.cancelSearch ) {
+			return;
+		}
+		if ( content && content.length ) {
+			message = this.options.messages.results( content.length );
+		} else {
+			message = this.options.messages.noResults;
+		}
+		this.liveRegion.children().hide();
+		$( "<div>" ).text( message ).appendTo( this.liveRegion );
+	}
+});
+
+var autocomplete = $.ui.autocomplete;
+
+
 
 }));
\ No newline at end of file
diff --git a/public/assets/tests/form.js b/public/assets/tests/form.js
index b92c8e357..e2c0337f3 100644
--- a/public/assets/tests/form.js
+++ b/public/assets/tests/form.js
@@ -1,6 +1,6 @@
 
 // form
-test( "form without @el", function() {
+test("form without @el", function() {
   var form = new App.ControllerForm()
 
   equal($(form.html()).is('div'), true)
@@ -8,8 +8,8 @@ test( "form without @el", function() {
   equal($(form.html()).hasClass('hide'), true)
 
 })
-test( "form elements check", function() {
-//    deepEqual( item, test.value, 'group set/get tests' );
+test("form elements check", function() {
+//    deepEqual(item, test.value, 'group set/get tests' );
   $('#forms').append('<hr><h1>form elements check</h1><form id="form1"></form>')
   var el = $('#form1')
   var defaults = {
@@ -49,61 +49,61 @@ test( "form elements check", function() {
     },
     autofocus: true
   });
-  equal( el.find('[name="input1"]').val(), '', 'check input1 value')
-  equal( el.find('[name="input1"]').prop('required'), false, 'check input1 required')
-//  equal( el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
+  equal(el.find('[name="input1"]').val(), '', 'check input1 value')
+  equal(el.find('[name="input1"]').prop('required'), false, 'check input1 required')
+//  equal(el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
 
-  equal( el.find('[name="input2"]').val(), '123abc', 'check input2 value')
-  equal( el.find('[name="input2"]').prop('required'), true, 'check input2 required')
-  equal( el.find('[name="input2"]').is(":focus"), false, 'check input2 focus')
+  equal(el.find('[name="input2"]').val(), '123abc', 'check input2 value')
+  equal(el.find('[name="input2"]').prop('required'), true, 'check input2 required')
+  equal(el.find('[name="input2"]').is(":focus"), false, 'check input2 focus')
 
-  equal( el.find('[name="password1"]').val(), '', 'check password1 value')
-  equal( el.find('[name="password1_confirm"]').val(), '', 'check password1 value')
-  equal( el.find('[name="password1"]').prop('required'), false, 'check password1 required')
-  equal( el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
+  equal(el.find('[name="password1"]').val(), '', 'check password1 value')
+  equal(el.find('[name="password1_confirm"]').val(), '', 'check password1 value')
+  equal(el.find('[name="password1"]').prop('required'), false, 'check password1 required')
+  equal(el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
 
-  equal( el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2"]').prop('required'), true, 'check password2 required')
-  equal( el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
+  equal(el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2"]').prop('required'), true, 'check password2 required')
+  equal(el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
 
-  equal( el.find('[name="textarea1"]').val(), '', 'check textarea1 value')
-  equal( el.find('[name="textarea1"]').prop('required'), false, 'check textarea1 required')
-  equal( el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
+  equal(el.find('[name="textarea1"]').val(), '', 'check textarea1 value')
+  equal(el.find('[name="textarea1"]').prop('required'), false, 'check textarea1 required')
+  equal(el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
 
-  equal( el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
-  equal( el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
-  equal( el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
+  equal(el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
+  equal(el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
+  equal(el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
 
-  equal( el.find('[name="select1"]').val(), 'false', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
-  equal( el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
+  equal(el.find('[name="select1"]').val(), 'false', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
 
-  equal( el.find('[name="select2"]').val(), 'true', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), true, 'check select2 required')
-  equal( el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
+  equal(el.find('[name="select2"]').val(), 'true', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), true, 'check select2 required')
+  equal(el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
 
-  equal( el.find('[name="selectmulti1"]').val(), 'false', 'check selectmulti1 value')
-  equal( el.find('[name="selectmulti1"]').prop('required'), false, 'check selectmulti1 required')
-  equal( el.find('[name="selectmulti1"]').is(":focus"), false, 'check selectmulti1 focus')
+  equal(el.find('[name="selectmulti1"]').val(), 'false', 'check selectmulti1 value')
+  equal(el.find('[name="selectmulti1"]').prop('required'), false, 'check selectmulti1 required')
+  equal(el.find('[name="selectmulti1"]').is(":focus"), false, 'check selectmulti1 focus')
 
-  equal( el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
-  equal( el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
+  equal(el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
+  equal(el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
 
-  //equal( el.find('[name="richtext1"]').val(), '', 'check textarea1 value')
-  //equal( el.find('[name="richtext1"]').prop('required'), false, 'check textarea1 required')
-  equal( el.find('[name="richtext1"]').is(":focus"), false, 'check textarea1 focus')
+  //equal(el.find('[name="richtext1"]').val(), '', 'check textarea1 value')
+  //equal(el.find('[name="richtext1"]').prop('required'), false, 'check textarea1 required')
+  equal(el.find('[name="richtext1"]').is(":focus"), false, 'check textarea1 focus')
 
-  //equal( el.find('[name="richtext2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
-  //equal( el.find('[name="richtext2"]').prop('required'), true, 'check textarea2 required')
-  equal( el.find('[name="richtext2"]').is(":focus"), false, 'check textarea2 focus')
+  //equal(el.find('[name="richtext2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
+  //equal(el.find('[name="richtext2"]').prop('required'), true, 'check textarea2 required')
+  equal(el.find('[name="richtext2"]').is(":focus"), false, 'check textarea2 focus')
 
 });
 
-test( "form params check", function() {
-//    deepEqual( item, test.value, 'group set/get tests' );
+test("form params check", function() {
+//    deepEqual(item, test.value, 'group set/get tests' );
 
   $('#forms').append('<hr><h1>form params check</h1><form id="form2"></form>')
   var el = $('#form2')
@@ -126,8 +126,8 @@ test( "form params check", function() {
     richtext6: '<div>lalu <b>b</b> lalu</div>',
     richtext7: "<div>&nbsp;<div>&nbsp;\n</div>  \n</div>",
     richtext8: '<div>lalu <i>b</i> lalu</div>',
-    datetime1: new Date( Date.parse('2015-01-11T12:40:00Z') ),
-    datetime3: new Date( Date.parse('2015-01-11T12:40:00Z') ),
+    datetime1: new Date(Date.parse('2015-01-11T12:40:00Z') ),
+    datetime3: new Date(Date.parse('2015-01-11T12:40:00Z') ),
     date1:     '2015-01-11',
     date3:     '2015-01-11',
     active1:   true,
@@ -174,50 +174,50 @@ test( "form params check", function() {
     params: defaults,
     autofocus: true
   });
-  equal( el.find('[name="input1"]').val(), '', 'check input1 value')
-  equal( el.find('[name="input1"]').prop('required'), false, 'check input1 required')
-//  equal( el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
+  equal(el.find('[name="input1"]').val(), '', 'check input1 value')
+  equal(el.find('[name="input1"]').prop('required'), false, 'check input1 required')
+//  equal(el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
 
-  equal( el.find('[name="input2"]').val(), '123abc', 'check input2 value')
-  equal( el.find('[name="input2"]').prop('required'), true, 'check input2 required')
-  equal( el.find('[name="input2"]').is(":focus"), false, 'check input2 focus')
+  equal(el.find('[name="input2"]').val(), '123abc', 'check input2 value')
+  equal(el.find('[name="input2"]').prop('required'), true, 'check input2 required')
+  equal(el.find('[name="input2"]').is(":focus"), false, 'check input2 focus')
 
-  equal( el.find('[name="password1"]').val(), '', 'check password1 value')
-  equal( el.find('[name="password1_confirm"]').val(), '', 'check password1 value')
-  equal( el.find('[name="password1"]').prop('required'), false, 'check password1 required')
-  equal( el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
+  equal(el.find('[name="password1"]').val(), '', 'check password1 value')
+  equal(el.find('[name="password1_confirm"]').val(), '', 'check password1 value')
+  equal(el.find('[name="password1"]').prop('required'), false, 'check password1 required')
+  equal(el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
 
-  equal( el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2"]').prop('required'), true, 'check password2 required')
-  equal( el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
+  equal(el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2"]').prop('required'), true, 'check password2 required')
+  equal(el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
 
-  equal( el.find('[name="textarea1"]').val(), '', 'check textarea1 value')
-  equal( el.find('[name="textarea1"]').prop('required'), false, 'check textarea1 required')
-  equal( el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
+  equal(el.find('[name="textarea1"]').val(), '', 'check textarea1 value')
+  equal(el.find('[name="textarea1"]').prop('required'), false, 'check textarea1 required')
+  equal(el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
 
-  equal( el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
-  equal( el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
-  equal( el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
+  equal(el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
+  equal(el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
+  equal(el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
 
-  equal( el.find('[name="select1"]').val(), 'false', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
-  equal( el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
+  equal(el.find('[name="select1"]').val(), 'false', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
 
-  equal( el.find('[name="select2"]').val(), 'true', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), true, 'check select2 required')
-  equal( el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
+  equal(el.find('[name="select2"]').val(), 'true', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), true, 'check select2 required')
+  equal(el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
 
-  equal( el.find('[name="selectmulti1"]').val(), 'false', 'check selectmulti1 value')
-  equal( el.find('[name="selectmulti1"]').prop('required'), false, 'check selectmulti1 required')
-  equal( el.find('[name="selectmulti1"]').is(":focus"), false, 'check selectmulti1 focus')
+  equal(el.find('[name="selectmulti1"]').val(), 'false', 'check selectmulti1 value')
+  equal(el.find('[name="selectmulti1"]').prop('required'), false, 'check selectmulti1 required')
+  equal(el.find('[name="selectmulti1"]').is(":focus"), false, 'check selectmulti1 focus')
 
-  equal( el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
-  equal( el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
+  equal(el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
+  equal(el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
 
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     input1: '',
     input2: '123abc',
@@ -258,12 +258,12 @@ test( "form params check", function() {
     active1: true,
     active2: false,
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
 
 });
 
-test( "form defaults + params check", function() {
-//    deepEqual( item, test.value, 'group set/get tests' );
+test("form defaults + params check", function() {
+//    deepEqual(item, test.value, 'group set/get tests' );
 
 // mix default and params -> check it -> add note
 // test auto completion
@@ -301,47 +301,47 @@ test( "form defaults + params check", function() {
     params: defaults,
     autofocus: true
   });
-  equal( el.find('[name="input1"]').val(), '', 'check input1 value')
-  equal( el.find('[name="input1"]').prop('required'), false, 'check input1 required')
-//  equal( el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
-  equal( el.find('[name="input2"]').val(), 'some used default', 'check input2 value')
-  equal( el.find('[name="input2"]').prop('required'), false, 'check input2 required')
+  equal(el.find('[name="input1"]').val(), '', 'check input1 value')
+  equal(el.find('[name="input1"]').prop('required'), false, 'check input1 required')
+//  equal(el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
+  equal(el.find('[name="input2"]').val(), 'some used default', 'check input2 value')
+  equal(el.find('[name="input2"]').prop('required'), false, 'check input2 required')
 
-  equal( el.find('[name="password1"]').val(), 'some used pass', 'check password1 value')
-  equal( el.find('[name="password1_confirm"]').val(), 'some used pass', 'check password1 value')
-  equal( el.find('[name="password1"]').prop('required'), true, 'check password1 required')
-  equal( el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
+  equal(el.find('[name="password1"]').val(), 'some used pass', 'check password1 value')
+  equal(el.find('[name="password1_confirm"]').val(), 'some used pass', 'check password1 value')
+  equal(el.find('[name="password1"]').prop('required'), true, 'check password1 required')
+  equal(el.find('[name="password1"]').is(":focus"), false, 'check password1 focus')
 
-  equal( el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
-  equal( el.find('[name="password2"]').prop('required'), true, 'check password2 required')
-  equal( el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
+  equal(el.find('[name="password2"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2_confirm"]').val(), 'pw1234<l>', 'check password2 value')
+  equal(el.find('[name="password2"]').prop('required'), true, 'check password2 required')
+  equal(el.find('[name="password2"]').is(":focus"), false, 'check password2 focus')
 
-  equal( el.find('[name="textarea1"]').val(), 'some used text', 'check textarea1 value')
-  equal( el.find('[name="textarea1"]').prop('required'), true, 'check textarea1 required')
-  equal( el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
+  equal(el.find('[name="textarea1"]').val(), 'some used text', 'check textarea1 value')
+  equal(el.find('[name="textarea1"]').prop('required'), true, 'check textarea1 required')
+  equal(el.find('[name="textarea1"]').is(":focus"), false, 'check textarea1 focus')
 
-  equal( el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
-  equal( el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
-  equal( el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
+  equal(el.find('[name="textarea2"]').val(), 'lalu <l> lalu', 'check textarea2 value')
+  equal(el.find('[name="textarea2"]').prop('required'), true, 'check textarea2 required')
+  equal(el.find('[name="textarea2"]').is(":focus"), false, 'check textarea2 focus')
 
-  equal( el.find('[name="select1"]').val(), 'false', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
-  equal( el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
+  equal(el.find('[name="select1"]').val(), 'false', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
 
-  equal( el.find('[name="select2"]').val(), 'false', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), false, 'check select2 required')
-  equal( el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
+  equal(el.find('[name="select2"]').val(), 'false', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), false, 'check select2 required')
+  equal(el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
 
-  equal( el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
-  equal( el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
+  equal(el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
+  equal(el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
 
 });
 
-test( "form dependend fields check", function() {
-//    deepEqual( item, test.value, 'group set/get tests' );
+test("form dependend fields check", function() {
+//    deepEqual(item, test.value, 'group set/get tests' );
 
 // mix default and params -> check it -> add note
 // test auto completion
@@ -357,8 +357,8 @@ test( "form dependend fields check", function() {
     select2: false,
     selectmulti2: [ false, true ],
     selectmultioption1: false,
-    datetime1: new Date( Date.parse('2015-01-11T12:40:00Z') ),
-    datetime3: new Date( Date.parse('2015-01-11T12:40:00Z') ),
+    datetime1: new Date(Date.parse('2015-01-11T12:40:00Z')),
+    datetime3: new Date(Date.parse('2015-01-11T12:40:00Z')),
     date1:     '2015-01-11',
     date3:     '2015-01-11',
   }
@@ -448,29 +448,29 @@ test( "form dependend fields check", function() {
     ],
     autofocus: true
   });
-  equal( el.find('[name="input1"]').val(), '', 'check input1 value')
-  equal( el.find('[name="input1"]').prop('required'), false, 'check input1 required')
-//  equal( el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
-  equal( el.find('[name="input2"]').val(), 'some used default', 'check input2 value')
-  equal( el.find('[name="input2"]').prop('required'), false, 'check input2 required')
+  equal(el.find('[name="input1"]').val(), '', 'check input1 value')
+  equal(el.find('[name="input1"]').prop('required'), false, 'check input1 required')
+//  equal(el.find('[name="input1"]').is(":focus"), true, 'check input1 focus')
+  equal(el.find('[name="input2"]').val(), 'some used default', 'check input2 value')
+  equal(el.find('[name="input2"]').prop('required'), false, 'check input2 required')
 
-  equal( el.find('[name="input3"]').val(), 'some used default', 'check input3 value')
-  equal( el.find('[name="input3"]').prop('required'), false, 'check input3 required')
+  equal(el.find('[name="input3"]').val(), 'some used default', 'check input3 value')
+  equal(el.find('[name="input3"]').prop('required'), false, 'check input3 required')
 
-  equal( el.find('[name="select1"]').val(), 'false', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
-  equal( el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
+  equal(el.find('[name="select1"]').val(), 'false', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').is(":focus"), false, 'check select1 focus')
 
-  equal( el.find('[name="select2"]').val(), 'false', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), false, 'check select2 required')
-  equal( el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
+  equal(el.find('[name="select2"]').val(), 'false', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), false, 'check select2 required')
+  equal(el.find('[name="select2"]').is(":focus"), false, 'check select2 focus')
 
-  equal( el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
-  equal( el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
-  equal( el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
+  equal(el.find('[name="selectmulti2"]').val()[0], 'true', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').val()[1], 'false', 'check selectmulti2 value')
+  equal(el.find('[name="selectmulti2"]').prop('required'), true, 'check selectmulti2 required')
+  equal(el.find('[name="selectmulti2"]').is(":focus"), false, 'check selectmulti2 focus')
 
-  var params = App.ControllerForm.params( el )
+  var params = App.ControllerForm.params(el)
   var test_params = {
     input1: "",
     input2: "some used default",
@@ -488,19 +488,19 @@ test( "form dependend fields check", function() {
     date3: '2015-01-11',
     date4: undefined,
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
 
   errors = form.validate(params)
   test_errors = {
     datetime4: "is required",
     date4:     "is required",
   }
-  deepEqual( errors, test_errors, 'validation errors check' )
-  App.ControllerForm.validate( { errors: errors, form: el } )
+  deepEqual(errors, test_errors, 'validation errors check')
+  App.ControllerForm.validate({ errors: errors, form: el })
 
   el.find('[name="select1"]').val('true')
   el.find('[name="select1"]').trigger('change')
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     input1: "",
     input2: undefined,
@@ -518,11 +518,11 @@ test( "form dependend fields check", function() {
     date3: '2015-01-11',
     date4: undefined,
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
 });
 
-test( "form handler check with and without fieldset", function() {
-//    deepEqual( item, test.value, 'group set/get tests' );
+test("form handler check with and without fieldset", function() {
+//    deepEqual(item, test.value, 'group set/get tests' );
 
 // mix default and params -> check it -> add note
 // test auto completion
@@ -550,8 +550,8 @@ test( "form handler check with and without fieldset", function() {
         options: { 1:'1', 2:'2', 3:'3' },
         default: 3,
       };
-      var newElement = ui.formGenItem( item, classname, form )
-      form.find('[name="select2"]').closest('.form-group').replaceWith( newElement )
+      var newElement = ui.formGenItem(item, classname, form)
+      form.find('[name="select2"]').closest('.form-group').replaceWith(newElement)
     }
     if (params['select1'] === 'a') {
       console.log('lala', params)
@@ -563,8 +563,8 @@ test( "form handler check with and without fieldset", function() {
         options: { 1:'1', 2:'2', 3:'3' },
         default: 1,
       };
-      var newElement = ui.formGenItem( item, classname, form )
-      form.find('[name="select2"]').closest('.form-group').replaceWith( newElement )
+      var newElement = ui.formGenItem(item, classname, form)
+      form.find('[name="select2"]').closest('.form-group').replaceWith(newElement)
     }
   }
 
@@ -582,34 +582,34 @@ test( "form handler check with and without fieldset", function() {
     ],
     //noFieldset: true,
   });
-  equal( el.find('[name="select1"]').val(), 'a', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').val(), 'a', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
 
-  equal( el.find('[name="select2"]').val(), '1', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), false, 'check select2 required')
+  equal(el.find('[name="select2"]').val(), '1', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), false, 'check select2 required')
 
-  var params = App.ControllerForm.params( el )
+  var params = App.ControllerForm.params(el)
   var test_params = {
     select1: 'a',
     select2: '1',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
   el.find('[name="select1"]').val('b')
   el.find('[name="select1"]').trigger('change')
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     select1: 'b',
     select2: '3',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
   el.find('[name="select1"]').val('a')
   el.find('[name="select1"]').trigger('change')
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     select1: 'a',
     select2: '1',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
 
   // test with noFieldset
   el.empty()
@@ -627,38 +627,38 @@ test( "form handler check with and without fieldset", function() {
     ],
     noFieldset: true,
   });
-  equal( el.find('[name="select1"]').val(), 'a', 'check select1 value')
-  equal( el.find('[name="select1"]').prop('required'), false, 'check select1 required')
+  equal(el.find('[name="select1"]').val(), 'a', 'check select1 value')
+  equal(el.find('[name="select1"]').prop('required'), false, 'check select1 required')
 
-  equal( el.find('[name="select2"]').val(), '1', 'check select2 value')
-  equal( el.find('[name="select2"]').prop('required'), false, 'check select2 required')
+  equal(el.find('[name="select2"]').val(), '1', 'check select2 value')
+  equal(el.find('[name="select2"]').prop('required'), false, 'check select2 required')
 
-  var params = App.ControllerForm.params( el )
+  var params = App.ControllerForm.params(el)
   var test_params = {
     select1: 'a',
     select2: '1',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
   el.find('[name="select1"]').val('b')
   el.find('[name="select1"]').trigger('change')
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     select1: 'b',
     select2: '3',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
   el.find('[name="select1"]').val('a')
   el.find('[name="select1"]').trigger('change')
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     select1: 'a',
     select2: '1',
   }
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
 
 });
 
-test( "form postmaster filter", function() {
+test("form postmaster filter", function() {
 
 // check match area
 
@@ -667,7 +667,7 @@ test( "form postmaster filter", function() {
 // add match rule
 
 // add set rule
-  App.TicketPriority.refresh( [
+  App.TicketPriority.refresh([
     {
       id:   1,
       name: 'prio 1',
@@ -677,7 +677,7 @@ test( "form postmaster filter", function() {
       name: 'prio 2',
     },
   ] )
-  App.Group.refresh( [
+  App.Group.refresh([
     {
       id:   1,
       name: 'group 1',
@@ -730,7 +730,7 @@ test( "form postmaster filter", function() {
     },
     params: defaults,
   });
-  params = App.ControllerForm.params( el )
+  params = App.ControllerForm.params(el)
   test_params = {
     input1: 'some not used default',
     input2: 'some name',
@@ -760,12 +760,12 @@ test( "form postmaster filter", function() {
       }
     },
   };
-  deepEqual( params, test_params, 'form param check' );
+  deepEqual(params, test_params, 'form param check')
   el.find('[name="set::x-zammad-ticket-priority_id::value"]').closest('.js-filterElement').find('.js-remove').click()
   el.find('[name="set::x-zammad-ticket-customer::value"]').closest('.js-filterElement').find('.js-remove').click()
-  App.Delay.set( function() {
-      test( "form param check after remove click", function() {
-        params = App.ControllerForm.params( el )
+  App.Delay.set(function() {
+      test("form param check after remove click", function() {
+        params = App.ControllerForm.params(el)
         test_params = {
           input1: 'some not used default',
           input2: 'some name',
@@ -789,7 +789,7 @@ test( "form postmaster filter", function() {
             },
           },
         };
-        deepEqual( params, test_params, 'form param check' );
+        deepEqual(params, test_params, 'form param check')
       });
     },
     1000
@@ -797,7 +797,7 @@ test( "form postmaster filter", function() {
 
 });
 
-test( "form selector", function() {
+test("form selector", function() {
   $('#forms').append('<hr><h1>form selector</h1><div><form id="form7"></form></div>')
   var el = $('#form7')
   var defaults = {
@@ -817,18 +817,18 @@ test( "form selector", function() {
     input1: 'some not used default33',
     input2: 'some name66',
   };
-  params = App.ControllerForm.params( el )
-  deepEqual( params, test_params, 'form param check via $("#form")' );
+  params = App.ControllerForm.params(el)
+  deepEqual(params, test_params, 'form param check via $("#form")')
 
-  params = App.ControllerForm.params( el.find('input') )
-  deepEqual( params, test_params, 'form param check via $("#form").find("input")' );
+  params = App.ControllerForm.params(el.find('input'))
+  deepEqual(params, test_params, 'form param check via $("#form").find("input")')
 
-  params = App.ControllerForm.params( el.parent() )
-  deepEqual( params, test_params, 'form param check via $("#form").parent()' );
+  params = App.ControllerForm.params(el.parent())
+  deepEqual(params, test_params, 'form param check via $("#form").parent()')
 
 });
 
-test( "form required_if + shown_if", function() {
+test("form required_if + shown_if", function() {
   $('#forms').append('<hr><h1>form required_if + shown_if</h1><div><form id="form8"></form></div>')
   var el = $('#form8')
   var defaults = {
@@ -856,13 +856,13 @@ test( "form required_if + shown_if", function() {
     input4: undefined,
     active: true,
   };
-  params = App.ControllerForm.params( el )
-  deepEqual( params, test_params, 'form param check via $("#form")' );
-  equal( el.find('[name="input2"]').attr('required'), 'required', 'check required attribute of input2 ')
-  equal( el.find('[name="input2"]').is(":visible"), true, 'check visible attribute of input2 ')
-  equal( el.find('[name="input3"]').attr('required'), 'required', 'check required attribute of input3 ')
-  equal( el.find('[name="input3"]').is(":visible"), true, 'check visible attribute of input3 ')
-  equal( el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4 ')
+  params = App.ControllerForm.params(el)
+  deepEqual(params, test_params, 'form param check via $("#form")')
+  equal(el.find('[name="input2"]').attr('required'), 'required', 'check required attribute of input2 ')
+  equal(el.find('[name="input2"]').is(":visible"), true, 'check visible attribute of input2 ')
+  equal(el.find('[name="input3"]').attr('required'), 'required', 'check required attribute of input3 ')
+  equal(el.find('[name="input3"]').is(":visible"), true, 'check visible attribute of input3 ')
+  equal(el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4 ')
 
 
   el.find('[name="{boolean}active"]').val('false').trigger('change')
@@ -873,12 +873,12 @@ test( "form required_if + shown_if", function() {
     input4: undefined,
     active: false,
   };
-  params = App.ControllerForm.params( el )
-  deepEqual( params, test_params, 'form param check via $("#form")' );
-  equal( el.find('[name="input2"]').attr('required'), undefined, 'check required attribute of input2 ')
-  equal( el.find('[name="input2"]').is(":visible"), false, 'check visible attribute of input2 ')
-  equal( el.find('[name="input3"]').is(":visible"), false, 'check visible attribute of input3 ')
-  equal( el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4 ')
+  params = App.ControllerForm.params(el)
+  deepEqual(params, test_params, 'form param check via $("#form")')
+  equal(el.find('[name="input2"]').attr('required'), undefined, 'check required attribute of input2')
+  equal(el.find('[name="input2"]').is(":visible"), false, 'check visible attribute of input2')
+  equal(el.find('[name="input3"]').is(":visible"), false, 'check visible attribute of input3')
+  equal(el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4')
 
 
   el.find('[name="{boolean}active"]').val('true').trigger('change')
@@ -889,12 +889,12 @@ test( "form required_if + shown_if", function() {
     input4: undefined,
     active: true,
   };
-  params = App.ControllerForm.params( el )
-  deepEqual( params, test_params, 'form param check via $("#form")' );
-  equal( el.find('[name="input2"]').attr('required'), 'required', 'check required attribute of input2 ')
-  equal( el.find('[name="input2"]').is(":visible"), true, 'check visible attribute of input2 ')
-  equal( el.find('[name="input3"]').attr('required'), 'required', 'check required attribute of input3 ')
-  equal( el.find('[name="input3"]').is(":visible"), true, 'check visible attribute of input3 ')
-  equal( el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4 ')
+  params = App.ControllerForm.params(el)
+  deepEqual(params, test_params, 'form param check via $("#form")')
+  equal(el.find('[name="input2"]').attr('required'), 'required', 'check required attribute of input2')
+  equal(el.find('[name="input2"]').is(":visible"), true, 'check visible attribute of input2')
+  equal(el.find('[name="input3"]').attr('required'), 'required', 'check required attribute of input3')
+  equal(el.find('[name="input3"]').is(":visible"), true, 'check visible attribute of input3')
+  equal(el.find('[name="input4"]').is(":visible"), false, 'check visible attribute of input4')
 
 });
\ No newline at end of file