/*!

 * jQuery UI Effects 1.10.3

 * http://jqueryui.com

 *

 * Copyright 2013 jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * http://api.jqueryui.com/category/effects-core/

 */

(function($, undefined) {

var dataSpace = "ui-effects-";

$.effects = {

	effect: {}

};

/*!

 * jQuery Color Animations v2.1.2

 * https://github.com/jquery/jquery-color

 *

 * Copyright 2013 jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * Date: Wed Jan 16 08:47:09 2013 -0600

 */

(function( jQuery, undefined ) {

	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",

	// plusequals test for += 100 -= 100

	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,

	// a set of RE's that can match strings and generate color tuples.

	stringParsers = [{

			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,

			parse: function( execResult ) {

				return [

					execResult[ 1 ],

					execResult[ 2 ],

					execResult[ 3 ],

					execResult[ 4 ]

				];

			}

		}, {

			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,

			parse: function( execResult ) {

				return [

					execResult[ 1 ] * 2.55,

					execResult[ 2 ] * 2.55,

					execResult[ 3 ] * 2.55,

					execResult[ 4 ]

				];

			}

		}, {

			// this regex ignores A-F because it's compared against an already lowercased string

			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,

			parse: function( execResult ) {

				return [

					parseInt( execResult[ 1 ], 16 ),

					parseInt( execResult[ 2 ], 16 ),

					parseInt( execResult[ 3 ], 16 )

				];

			}

		}, {

			// this regex ignores A-F because it's compared against an already lowercased string

			re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,

			parse: function( execResult ) {

				return [

					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),

					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),

					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )

				];

			}

		}, {

			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,

			space: "hsla",

			parse: function( execResult ) {

				return [

					execResult[ 1 ],

					execResult[ 2 ] / 100,

					execResult[ 3 ] / 100,

					execResult[ 4 ]

				];

			}

		}],

	// jQuery.Color( )

	color = jQuery.Color = function( color, green, blue, alpha ) {

		return new jQuery.Color.fn.parse( color, green, blue, alpha );

	},

	spaces = {

		rgba: {

			props: {

				red: {

					idx: 0,

					type: "byte"

				},

				green: {

					idx: 1,

					type: "byte"

				},

				blue: {

					idx: 2,

					type: "byte"

				}

			}

		},

		hsla: {

			props: {

				hue: {

					idx: 0,

					type: "degrees"

				},

				saturation: {

					idx: 1,

					type: "percent"

				},

				lightness: {

					idx: 2,

					type: "percent"

				}

			}

		}

	},

	propTypes = {

		"byte": {

			floor: true,

			max: 255

		},

		"percent": {

			max: 1

		},

		"degrees": {

			mod: 360,

			floor: true

		}

	},

	support = color.support = {},

	// element for support tests

	supportElem = jQuery( "<p>" )[ 0 ],

	// colors = jQuery.Color.names

	colors,

	// local aliases of functions called often

	each = jQuery.each;

// determine rgba support immediately

supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";

support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;

// define cache name and alpha properties

// for rgba and hsla spaces

each( spaces, function( spaceName, space ) {

	space.cache = "_" + spaceName;

	space.props.alpha = {

		idx: 3,

		type: "percent",

		def: 1

	};

});

function clamp( value, prop, allowEmpty ) {

	var type = propTypes[ prop.type ] || {};

	if ( value == null ) {

		return (allowEmpty || !prop.def) ? null : prop.def;

	}

	// ~~ is an short way of doing floor for positive numbers

	value = type.floor ? ~~value : parseFloat( value );

	// IE will pass in empty strings as value for alpha,

	// which will hit this case

	if ( isNaN( value ) ) {

		return prop.def;

	}

	if ( type.mod ) {

		// we add mod before modding to make sure that negatives values

		// get converted properly: -10 -> 350

		return (value + type.mod) % type.mod;

	}

	// for now all property types without mod have min and max

	return 0 > value ? 0 : type.max < value ? type.max : value;

}

function stringParse( string ) {

	var inst = color(),

		rgba = inst._rgba = [];

	string = string.toLowerCase();

	each( stringParsers, function( i, parser ) {

		var parsed,

			match = parser.re.exec( string ),

			values = match && parser.parse( match ),

			spaceName = parser.space || "rgba";

		if ( values ) {

			parsed = inst[ spaceName ]( values );

			// if this was an rgba parse the assignment might happen twice

			// oh well....

			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];

			rgba = inst._rgba = parsed._rgba;

			// exit each( stringParsers ) here because we matched

			return false;

		}

	});

	// Found a stringParser that handled it

	if ( rgba.length ) {

		// if this came from a parsed string, force "transparent" when alpha is 0

		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)

		if ( rgba.join() === "0,0,0,0" ) {

			jQuery.extend( rgba, colors.transparent );

		}

		return inst;

	}

	// named colors

	return colors[ string ];

}

color.fn = jQuery.extend( color.prototype, {

	parse: function( red, green, blue, alpha ) {

		if ( red === undefined ) {

			this._rgba = [ null, null, null, null ];

			return this;

		}

		if ( red.jquery || red.nodeType ) {

			red = jQuery( red ).css( green );

			green = undefined;

		}

		var inst = this,

			type = jQuery.type( red ),

			rgba = this._rgba = [];

		// more than 1 argument specified - assume ( red, green, blue, alpha )

		if ( green !== undefined ) {

			red = [ red, green, blue, alpha ];

			type = "array";

		}

		if ( type === "string" ) {

			return this.parse( stringParse( red ) || colors._default );

		}

		if ( type === "array" ) {

			each( spaces.rgba.props, function( key, prop ) {

				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );

			});

			return this;

		}

		if ( type === "object" ) {

			if ( red instanceof color ) {

				each( spaces, function( spaceName, space ) {

					if ( red[ space.cache ] ) {

						inst[ space.cache ] = red[ space.cache ].slice();

					}

				});

			} else {

				each( spaces, function( spaceName, space ) {

					var cache = space.cache;

					each( space.props, function( key, prop ) {

						// if the cache doesn't exist, and we know how to convert

						if ( !inst[ cache ] && space.to ) {

							// if the value was null, we don't need to copy it

							// if the key was alpha, we don't need to copy it either

							if ( key === "alpha" || red[ key ] == null ) {

								return;

							}

							inst[ cache ] = space.to( inst._rgba );

						}

						// this is the only case where we allow nulls for ALL properties.

						// call clamp with alwaysAllowEmpty

						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );

					});

					// everything defined but alpha?

					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {

						// use the default of 1

						inst[ cache ][ 3 ] = 1;

						if ( space.from ) {

							inst._rgba = space.from( inst[ cache ] );

						}

					}

				});

			}

			return this;

		}

	},

	is: function( compare ) {

		var is = color( compare ),

			same = true,

			inst = this;

		each( spaces, function( _, space ) {

			var localCache,

				isCache = is[ space.cache ];

			if (isCache) {

				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];

				each( space.props, function( _, prop ) {

					if ( isCache[ prop.idx ] != null ) {

						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );

						return same;

					}

				});

			}

			return same;

		});

		return same;

	},

	_space: function() {

		var used = [],

			inst = this;

		each( spaces, function( spaceName, space ) {

			if ( inst[ space.cache ] ) {

				used.push( spaceName );

			}

		});

		return used.pop();

	},

	transition: function( other, distance ) {

		var end = color( other ),

			spaceName = end._space(),

			space = spaces[ spaceName ],

			startColor = this.alpha() === 0 ? color( "transparent" ) : this,

			start = startColor[ space.cache ] || space.to( startColor._rgba ),

			result = start.slice();

		end = end[ space.cache ];

		each( space.props, function( key, prop ) {

			var index = prop.idx,

				startValue = start[ index ],

				endValue = end[ index ],

				type = propTypes[ prop.type ] || {};

			// if null, don't override start value

			if ( endValue === null ) {

				return;

			}

			// if null - use end

			if ( startValue === null ) {

				result[ index ] = endValue;

			} else {