1 /*!

     2  * jQuery UI Effects 1.10.3

     3  * http://jqueryui.com

     4  *

     5  * Copyright 2013 jQuery Foundation and other contributors

     6  * Released under the MIT license.

     7  * http://jquery.org/license

     8  *

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

    10  */

    11 (function($, undefined) {

    12 

    13 var dataSpace = "ui-effects-";

    14 

    15 $.effects = {

    16 	effect: {}

    17 };

    18 

    19 /*!

    20  * jQuery Color Animations v2.1.2

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

    22  *

    23  * Copyright 2013 jQuery Foundation and other contributors

    24  * Released under the MIT license.

    25  * http://jquery.org/license

    26  *

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

    28  */

    29 (function( jQuery, undefined ) {

    30 

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

    32 

    33 	// plusequals test for += 100 -= 100

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

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

    36 	stringParsers = [{

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

    38 			parse: function( execResult ) {

    39 				return [

    40 					execResult[ 1 ],

    41 					execResult[ 2 ],

    42 					execResult[ 3 ],

    43 					execResult[ 4 ]

    44 				];

    45 			}

    46 		}, {

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

    48 			parse: function( execResult ) {

    49 				return [

    50 					execResult[ 1 ] * 2.55,

    51 					execResult[ 2 ] * 2.55,

    52 					execResult[ 3 ] * 2.55,

    53 					execResult[ 4 ]

    54 				];

    55 			}

    56 		}, {

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

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

    59 			parse: function( execResult ) {

    60 				return [

    61 					parseInt( execResult[ 1 ], 16 ),

    62 					parseInt( execResult[ 2 ], 16 ),

    63 					parseInt( execResult[ 3 ], 16 )

    64 				];

    65 			}

    66 		}, {

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

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

    69 			parse: function( execResult ) {

    70 				return [

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

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

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

    74 				];

    75 			}

    76 		}, {

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

    78 			space: "hsla",

    79 			parse: function( execResult ) {

    80 				return [

    81 					execResult[ 1 ],

    82 					execResult[ 2 ] / 100,

    83 					execResult[ 3 ] / 100,

    84 					execResult[ 4 ]

    85 				];

    86 			}

    87 		}],

    88 

    89 	// jQuery.Color( )

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

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

    92 	},

    93 	spaces = {

    94 		rgba: {

    95 			props: {

    96 				red: {

    97 					idx: 0,

    98 					type: "byte"

    99 				},

   100 				green: {

   101 					idx: 1,

   102 					type: "byte"

   103 				},

   104 				blue: {

   105 					idx: 2,

   106 					type: "byte"

   107 				}

   108 			}

   109 		},

   110 

   111 		hsla: {

   112 			props: {

   113 				hue: {

   114 					idx: 0,

   115 					type: "degrees"

   116 				},

   117 				saturation: {

   118 					idx: 1,

   119 					type: "percent"

   120 				},

   121 				lightness: {

   122 					idx: 2,

   123 					type: "percent"

   124 				}

   125 			}

   126 		}

   127 	},

   128 	propTypes = {

   129 		"byte": {

   130 			floor: true,

   131 			max: 255

   132 		},

   133 		"percent": {

   134 			max: 1

   135 		},

   136 		"degrees": {

   137 			mod: 360,

   138 			floor: true

   139 		}

   140 	},

   141 	support = color.support = {},

   142 

   143 	// element for support tests

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

   145 

   146 	// colors = jQuery.Color.names

   147 	colors,

   148 

   149 	// local aliases of functions called often

   150 	each = jQuery.each;

   151 

   152 // determine rgba support immediately

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

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

   155 

   156 // define cache name and alpha properties

   157 // for rgba and hsla spaces

   158 each( spaces, function( spaceName, space ) {

   159 	space.cache = "_" + spaceName;

   160 	space.props.alpha = {

   161 		idx: 3,

   162 		type: "percent",

   163 		def: 1

   164 	};

   165 });

   166 

   167 function clamp( value, prop, allowEmpty ) {

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

   169 

   170 	if ( value == null ) {

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

   172 	}

   173 

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

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

   176 

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

   178 	// which will hit this case

   179 	if ( isNaN( value ) ) {

   180 		return prop.def;

   181 	}

   182 

   183 	if ( type.mod ) {

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

   185 		// get converted properly: -10 -> 350

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

   187 	}

   188 

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

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

   191 }

   192 

   193 function stringParse( string ) {

   194 	var inst = color(),

   195 		rgba = inst._rgba = [];

   196 

   197 	string = string.toLowerCase();

   198 

   199 	each( stringParsers, function( i, parser ) {

   200 		var parsed,

   201 			match = parser.re.exec( string ),

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

   203 			spaceName = parser.space || "rgba";

   204 

   205 		if ( values ) {

   206 			parsed = inst[ spaceName ]( values );

   207 

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

   209 			// oh well....

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

   211 			rgba = inst._rgba = parsed._rgba;

   212 

   213 			// exit each( stringParsers ) here because we matched

   214 			return false;

   215 		}

   216 	});

   217 

   218 	// Found a stringParser that handled it

   219 	if ( rgba.length ) {

   220 

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

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

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

   224 			jQuery.extend( rgba, colors.transparent );

   225 		}

   226 		return inst;

   227 	}

   228 

   229 	// named colors

   230 	return colors[ string ];

   231 }

   232 

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

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

   235 		if ( red === undefined ) {

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

   237 			return this;

   238 		}

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

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

   241 			green = undefined;

   242 		}

   243 

   244 		var inst = this,

   245 			type = jQuery.type( red ),

   246 			rgba = this._rgba = [];

   247 

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

   249 		if ( green !== undefined ) {

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

   251 			type = "array";

   252 		}

   253 

   254 		if ( type === "string" ) {

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

   256 		}

   257 

   258 		if ( type === "array" ) {

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

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

   261 			});

   262 			return this;

   263 		}

   264 

   265 		if ( type === "object" ) {

   266 			if ( red instanceof color ) {

   267 				each( spaces, function( spaceName, space ) {

   268 					if ( red[ space.cache ] ) {

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

   270 					}

   271 				});

   272 			} else {

   273 				each( spaces, function( spaceName, space ) {

   274 					var cache = space.cache;

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

   276 

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

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

   279 

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

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

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

   283 								return;

   284 							}

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

   286 						}

   287 

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

   289 						// call clamp with alwaysAllowEmpty

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

   291 					});

   292 

   293 					// everything defined but alpha?

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

   295 						// use the default of 1

   296 						inst[ cache ][ 3 ] = 1;

   297 						if ( space.from ) {

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

   299 						}

   300 					}

   301 				});

   302 			}

   303 			return this;

   304 		}

   305 	},

   306 	is: function( compare ) {

   307 		var is = color( compare ),

   308 			same = true,

   309 			inst = this;

   310 

   311 		each( spaces, function( _, space ) {

   312 			var localCache,

   313 				isCache = is[ space.cache ];

   314 			if (isCache) {

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

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

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

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

   319 						return same;

   320 					}

   321 				});

   322 			}

   323 			return same;

   324 		});

   325 		return same;

   326 	},

   327 	_space: function() {

   328 		var used = [],

   329 			inst = this;

   330 		each( spaces, function( spaceName, space ) {

   331 			if ( inst[ space.cache ] ) {

   332 				used.push( spaceName );

   333 			}

   334 		});

   335 		return used.pop();

   336 	},

   337 	transition: function( other, distance ) {

   338 		var end = color( other ),

   339 			spaceName = end._space(),

   340 			space = spaces[ spaceName ],

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

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

   343 			result = start.slice();

   344 

   345 		end = end[ space.cache ];

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

   347 			var index = prop.idx,

   348 				startValue = start[ index ],

   349 				endValue = end[ index ],

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

   351 

   352 			// if null, don't override start value

   353 			if ( endValue === null ) {

   354 				return;

   355 			}

   356 			// if null - use end

   357 			if ( startValue === null ) {

   358 				result[ index ] = endValue;

   359 			} else {

   360 				if ( type.mod ) {

   361 					if ( endValue - startValue > type.mod / 2 ) {

   362 						startValue += type.mod;

   363 					} else if ( startValue - endValue > type.mod / 2 ) {

   364 						startValue -= type.mod;

   365 					}

   366 				}

   367 				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );

   368 			}

   369 		});

   370 		return this[ spaceName ]( result );

   371 	},

   372 	blend: function( opaque ) {

   373 		// if we are already opaque - return ourself

   374 		if ( this._rgba[ 3 ] === 1 ) {

   375 			return this;

   376 		}

   377 

   378 		var rgb = this._rgba.slice(),

   379 			a = rgb.pop(),

   380 			blend = color( opaque )._rgba;

   381 

   382 		return color( jQuery.map( rgb, function( v, i ) {

   383 			return ( 1 - a ) * blend[ i ] + a * v;

   384 		}));

   385 	},

   386 	toRgbaString: function() {

   387 		var prefix = "rgba(",

   388 			rgba = jQuery.map( this._rgba, function( v, i ) {

   389 				return v == null ? ( i > 2 ? 1 : 0 ) : v;

   390 			});

   391 

   392 		if ( rgba[ 3 ] === 1 ) {

   393 			rgba.pop();

   394 			prefix = "rgb(";

   395 		}

   396 

   397 		return prefix + rgba.join() + ")";

   398 	},

   399 	toHslaString: function() {

   400 		var prefix = "hsla(",

   401 			hsla = jQuery.map( this.hsla(), function( v, i ) {

   402 				if ( v == null ) {

   403 					v = i > 2 ? 1 : 0;

   404 				}

   405 

   406 				// catch 1 and 2

   407 				if ( i && i < 3 ) {

   408 					v = Math.round( v * 100 ) + "%";

   409 				}

   410 				return v;

   411 			});

   412 

   413 		if ( hsla[ 3 ] === 1 ) {

   414 			hsla.pop();

   415 			prefix = "hsl(";

   416 		}

   417 		return prefix + hsla.join() + ")";

   418 	},

   419 	toHexString: function( includeAlpha ) {

   420 		var rgba = this._rgba.slice(),

   421 			alpha = rgba.pop();

   422 

   423 		if ( includeAlpha ) {

   424 			rgba.push( ~~( alpha * 255 ) );

   425 		}

   426 

   427 		return "#" + jQuery.map( rgba, function( v ) {

   428 

   429 			// default to 0 when nulls exist

   430 			v = ( v || 0 ).toString( 16 );

   431 			return v.length === 1 ? "0" + v : v;

   432 		}).join("");

   433 	},

   434 	toString: function() {

   435 		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();

   436 	}

   437 });

   438 color.fn.parse.prototype = color.fn;

   439 

   440 // hsla conversions adapted from:

   441 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021

   442 

   443 function hue2rgb( p, q, h ) {

   444 	h = ( h + 1 ) % 1;

   445 	if ( h * 6 < 1 ) {

   446 		return p + (q - p) * h * 6;

   447 	}

   448 	if ( h * 2 < 1) {

   449 		return q;

   450 	}

   451 	if ( h * 3 < 2 ) {

   452 		return p + (q - p) * ((2/3) - h) * 6;

   453 	}

   454 	return p;

   455 }

   456 

   457 spaces.hsla.to = function ( rgba ) {

   458 	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {

   459 		return [ null, null, null, rgba[ 3 ] ];

   460 	}

   461 	var r = rgba[ 0 ] / 255,

   462 		g = rgba[ 1 ] / 255,

   463 		b = rgba[ 2 ] / 255,

   464 		a = rgba[ 3 ],

   465 		max = Math.max( r, g, b ),

   466 		min = Math.min( r, g, b ),

   467 		diff = max - min,

   468 		add = max + min,

   469 		l = add * 0.5,

   470 		h, s;

   471 

   472 	if ( min === max ) {

   473 		h = 0;

   474 	} else if ( r === max ) {

   475 		h = ( 60 * ( g - b ) / diff ) + 360;

   476 	} else if ( g === max ) {

   477 		h = ( 60 * ( b - r ) / diff ) + 120;

   478 	} else {

   479 		h = ( 60 * ( r - g ) / diff ) + 240;

   480 	}

   481 

   482 	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%

   483 	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)

   484 	if ( diff === 0 ) {

   485 		s = 0;

   486 	} else if ( l <= 0.5 ) {

   487 		s = diff / add;

   488 	} else {

   489 		s = diff / ( 2 - add );

   490 	}

   491 	return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];

   492 };

   493 

   494 spaces.hsla.from = function ( hsla ) {

   495 	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {

   496 		return [ null, null, null, hsla[ 3 ] ];

   497 	}

   498 	var h = hsla[ 0 ] / 360,

   499 		s = hsla[ 1 ],

   500 		l = hsla[ 2 ],

   501 		a = hsla[ 3 ],

   502 		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,

   503 		p = 2 * l - q;

   504 

   505 	return [

   506 		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),

   507 		Math.round( hue2rgb( p, q, h ) * 255 ),

   508 		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),

   509 		a

   510 	];

   511 };

   512 

   513 

   514 each( spaces, function( spaceName, space ) {

   515 	var props = space.props,

   516 		cache = space.cache,

   517 		to = space.to,

   518 		from = space.from;

   519 

   520 	// makes rgba() and hsla()

   521 	color.fn[ spaceName ] = function( value ) {

   522 

   523 		// generate a cache for this space if it doesn't exist

   524 		if ( to && !this[ cache ] ) {

   525 			this[ cache ] = to( this._rgba );

   526 		}

   527 		if ( value === undefined ) {

   528 			return this[ cache ].slice();

   529 		}

   530 

   531 		var ret,

   532 			type = jQuery.type( value ),

   533 			arr = ( type === "array" || type === "object" ) ? value : arguments,

   534 			local = this[ cache ].slice();

   535 

   536 		each( props, function( key, prop ) {

   537 			var val = arr[ type === "object" ? key : prop.idx ];

   538 			if ( val == null ) {

   539 				val = local[ prop.idx ];

   540 			}

   541 			local[ prop.idx ] = clamp( val, prop );

   542 		});

   543 

   544 		if ( from ) {

   545 			ret = color( from( local ) );

   546 			ret[ cache ] = local;

   547 			return ret;

   548 		} else {

   549 			return color( local );

   550 		}

   551 	};

   552 

   553 	// makes red() green() blue() alpha() hue() saturation() lightness()

   554 	each( props, function( key, prop ) {

   555 		// alpha is included in more than one space

   556 		if ( color.fn[ key ] ) {

   557 			return;

   558 		}

   559 		color.fn[ key ] = function( value ) {

   560 			var vtype = jQuery.type( value ),

   561 				fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),

   562 				local = this[ fn ](),

   563 				cur = local[ prop.idx ],

   564 				match;

   565 

   566 			if ( vtype === "undefined" ) {

   567 				return cur;

   568 			}

   569 

   570 			if ( vtype === "function" ) {

   571 				value = value.call( this, cur );

   572 				vtype = jQuery.type( value );

   573 			}

   574 			if ( value == null && prop.empty ) {

   575 				return this;

   576 			}

   577 			if ( vtype === "string" ) {

   578 				match = rplusequals.exec( value );

   579 				if ( match ) {

   580 					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );

   581 				}

   582 			}

   583 			local[ prop.idx ] = value;

   584 			return this[ fn ]( local );

   585 		};

   586 	});

   587 });

   588 

   589 // add cssHook and .fx.step function for each named hook.

   590 // accept a space separated string of properties

   591 color.hook = function( hook ) {

   592 	var hooks = hook.split( " " );

   593 	each( hooks, function( i, hook ) {

   594 		jQuery.cssHooks[ hook ] = {

   595 			set: function( elem, value ) {

   596 				var parsed, curElem,

   597 					backgroundColor = "";

   598 

   599 				if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {

   600 					value = color( parsed || value );

   601 					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {

   602 						curElem = hook === "backgroundColor" ? elem.parentNode : elem;

   603 						while (

   604 							(backgroundColor === "" || backgroundColor === "transparent") &&

   605 							curElem && curElem.style

   606 						) {

   607 							try {

   608 								backgroundColor = jQuery.css( curElem, "backgroundColor" );

   609 								curElem = curElem.parentNode;

   610 							} catch ( e ) {

   611 							}

   612 						}

   613 

   614 						value = value.blend( backgroundColor && backgroundColor !== "transparent" ?

   615 							backgroundColor :

   616 							"_default" );

   617 					}

   618 

   619 					value = value.toRgbaString();

   620 				}

   621 				try {

   622 					elem.style[ hook ] = value;

   623 				} catch( e ) {

   624 					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'

   625 				}

   626 			}

   627 		};

   628 		jQuery.fx.step[ hook ] = function( fx ) {

   629 			if ( !fx.colorInit ) {

   630 				fx.start = color( fx.elem, hook );

   631 				fx.end = color( fx.end );

   632 				fx.colorInit = true;

   633 			}

   634 			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );

   635 		};

   636 	});

   637 

   638 };

   639 

   640 color.hook( stepHooks );

   641 

   642 jQuery.cssHooks.borderColor = {

   643 	expand: function( value ) {

   644 		var expanded = {};

   645 

   646 		each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {

   647 			expanded[ "border" + part + "Color" ] = value;

   648 		});

   649 		return expanded;

   650 	}

   651 };

   652 

   653 // Basic color names only.

   654 // Usage of any of the other color names requires adding yourself or including

   655 // jquery.color.svg-names.js.

   656 colors = jQuery.Color.names = {

   657 	// 4.1. Basic color keywords

   658 	aqua: "#00ffff",

   659 	black: "#000000",

   660 	blue: "#0000ff",

   661 	fuchsia: "#ff00ff",

   662 	gray: "#808080",

   663 	green: "#008000",

   664 	lime: "#00ff00",

   665 	maroon: "#800000",

   666 	navy: "#000080",

   667 	olive: "#808000",

   668 	purple: "#800080",

   669 	red: "#ff0000",

   670 	silver: "#c0c0c0",

   671 	teal: "#008080",

   672 	white: "#ffffff",

   673 	yellow: "#ffff00",

   674 

   675 	// 4.2.3. "transparent" color keyword

   676 	transparent: [ null, null, null, 0 ],

   677 

   678 	_default: "#ffffff"

   679 };

   680 

   681 })( jQuery );

   682 

   683 

   684 /******************************************************************************/

   685 /****************************** CLASS ANIMATIONS ******************************/

   686 /******************************************************************************/

   687 (function() {

   688 

   689 var classAnimationActions = [ "add", "remove", "toggle" ],

   690 	shorthandStyles = {

   691 		border: 1,

   692 		borderBottom: 1,

   693 		borderColor: 1,

   694 		borderLeft: 1,

   695 		borderRight: 1,

   696 		borderTop: 1,

   697 		borderWidth: 1,

   698 		margin: 1,

   699 		padding: 1

   700 	};

   701 

   702 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {

   703 	$.fx.step[ prop ] = function( fx ) {

   704 		if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {

   705 			jQuery.style( fx.elem, prop, fx.end );

   706 			fx.setAttr = true;

   707 		}

   708 	};

   709 });

   710 

   711 function getElementStyles( elem ) {

   712 	var key, len,

   713 		style = elem.ownerDocument.defaultView ?

   714 			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :

   715 			elem.currentStyle,

   716 		styles = {};

   717 

   718 	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {

   719 		len = style.length;

   720 		while ( len-- ) {

   721 			key = style[ len ];

   722 			if ( typeof style[ key ] === "string" ) {

   723 				styles[ $.camelCase( key ) ] = style[ key ];

   724 			}

   725 		}

   726 	// support: Opera, IE <9

   727 	} else {

   728 		for ( key in style ) {

   729 			if ( typeof style[ key ] === "string" ) {

   730 				styles[ key ] = style[ key ];

   731 			}

   732 		}

   733 	}

   734 

   735 	return styles;

   736 }

   737 

   738 

   739 function styleDifference( oldStyle, newStyle ) {

   740 	var diff = {},

   741 		name, value;

   742 

   743 	for ( name in newStyle ) {

   744 		value = newStyle[ name ];

   745 		if ( oldStyle[ name ] !== value ) {

   746 			if ( !shorthandStyles[ name ] ) {

   747 				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {

   748 					diff[ name ] = value;

   749 				}

   750 			}

   751 		}

   752 	}

   753 

   754 	return diff;

   755 }

   756 

   757 // support: jQuery <1.8

   758 if ( !$.fn.addBack ) {

   759 	$.fn.addBack = function( selector ) {

   760 		return this.add( selector == null ?

   761 			this.prevObject : this.prevObject.filter( selector )

   762 		);

   763 	};

   764 }

   765 

   766 $.effects.animateClass = function( value, duration, easing, callback ) {

   767 	var o = $.speed( duration, easing, callback );

   768 

   769 	return this.queue( function() {

   770 		var animated = $( this ),

   771 			baseClass = animated.attr( "class" ) || "",

   772 			applyClassChange,

   773 			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;

   774 

   775 		// map the animated objects to store the original styles.

   776 		allAnimations = allAnimations.map(function() {

   777 			var el = $( this );

   778 			return {

   779 				el: el,

   780 				start: getElementStyles( this )

   781 			};

   782 		});

   783 

   784 		// apply class change

   785 		applyClassChange = function() {

   786 			$.each( classAnimationActions, function(i, action) {

   787 				if ( value[ action ] ) {

   788 					animated[ action + "Class" ]( value[ action ] );

   789 				}

   790 			});

   791 		};

   792 		applyClassChange();

   793 

   794 		// map all animated objects again - calculate new styles and diff

   795 		allAnimations = allAnimations.map(function() {

   796 			this.end = getElementStyles( this.el[ 0 ] );

   797 			this.diff = styleDifference( this.start, this.end );

   798 			return this;

   799 		});

   800 

   801 		// apply original class

   802 		animated.attr( "class", baseClass );

   803 

   804 		// map all animated objects again - this time collecting a promise

   805 		allAnimations = allAnimations.map(function() {

   806 			var styleInfo = this,

   807 				dfd = $.Deferred(),

   808 				opts = $.extend({}, o, {

   809 					queue: false,

   810 					complete: function() {

   811 						dfd.resolve( styleInfo );

   812 					}

   813 				});

   814 

   815 			this.el.animate( this.diff, opts );

   816 			return dfd.promise();

   817 		});

   818 

   819 		// once all animations have completed:

   820 		$.when.apply( $, allAnimations.get() ).done(function() {

   821 

   822 			// set the final class

   823 			applyClassChange();

   824 

   825 			// for each animated element,

   826 			// clear all css properties that were animated

   827 			$.each( arguments, function() {

   828 				var el = this.el;

   829 				$.each( this.diff, function(key) {

   830 					el.css( key, "" );

   831 				});

   832 			});

   833 

   834 			// this is guarnteed to be there if you use jQuery.speed()

   835 			// it also handles dequeuing the next anim...

   836 			o.complete.call( animated[ 0 ] );

   837 		});

   838 	});

   839 };

   840 

   841 $.fn.extend({

   842 	addClass: (function( orig ) {

   843 		return function( classNames, speed, easing, callback ) {

   844 			return speed ?

   845 				$.effects.animateClass.call( this,

   846 					{ add: classNames }, speed, easing, callback ) :

   847 				orig.apply( this, arguments );

   848 		};

   849 	})( $.fn.addClass ),

   850 

   851 	removeClass: (function( orig ) {

   852 		return function( classNames, speed, easing, callback ) {

   853 			return arguments.length > 1 ?

   854 				$.effects.animateClass.call( this,

   855 					{ remove: classNames }, speed, easing, callback ) :

   856 				orig.apply( this, arguments );

   857 		};

   858 	})( $.fn.removeClass ),

   859 

   860 	toggleClass: (function( orig ) {

   861 		return function( classNames, force, speed, easing, callback ) {

   862 			if ( typeof force === "boolean" || force === undefined ) {

   863 				if ( !speed ) {

   864 					// without speed parameter

   865 					return orig.apply( this, arguments );

   866 				} else {

   867 					return $.effects.animateClass.call( this,

   868 						(force ? { add: classNames } : { remove: classNames }),

   869 						speed, easing, callback );

   870 				}

   871 			} else {

   872 				// without force parameter

   873 				return $.effects.animateClass.call( this,

   874 					{ toggle: classNames }, force, speed, easing );

   875 			}

   876 		};

   877 	})( $.fn.toggleClass ),

   878 

   879 	switchClass: function( remove, add, speed, easing, callback) {

   880 		return $.effects.animateClass.call( this, {

   881 			add: add,

   882 			remove: remove

   883 		}, speed, easing, callback );

   884 	}

   885 });

   886 

   887 })();

   888 

   889 /******************************************************************************/

   890 /*********************************** EFFECTS **********************************/

   891 /******************************************************************************/

   892 

   893 (function() {

   894 

   895 $.extend( $.effects, {

   896 	version: "1.10.3",

   897 

   898 	// Saves a set of properties in a data storage

   899 	save: function( element, set ) {

   900 		for( var i=0; i < set.length; i++ ) {

   901 			if ( set[ i ] !== null ) {

   902 				element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );

   903 			}

   904 		}

   905 	},

   906 

   907 	// Restores a set of previously saved properties from a data storage

   908 	restore: function( element, set ) {

   909 		var val, i;

   910 		for( i=0; i < set.length; i++ ) {

   911 			if ( set[ i ] !== null ) {

   912 				val = element.data( dataSpace + set[ i ] );

   913 				// support: jQuery 1.6.2

   914 				// http://bugs.jquery.com/ticket/9917

   915 				// jQuery 1.6.2 incorrectly returns undefined for any falsy value.

   916 				// We can't differentiate between "" and 0 here, so we just assume

   917 				// empty string since it's likely to be a more common value...

   918 				if ( val === undefined ) {

   919 					val = "";

   920 				}

   921 				element.css( set[ i ], val );

   922 			}

   923 		}

   924 	},

   925 

   926 	setMode: function( el, mode ) {

   927 		if (mode === "toggle") {

   928 			mode = el.is( ":hidden" ) ? "show" : "hide";

   929 		}

   930 		return mode;

   931 	},

   932 

   933 	// Translates a [top,left] array into a baseline value

   934 	// this should be a little more flexible in the future to handle a string & hash

   935 	getBaseline: function( origin, original ) {

   936 		var y, x;

   937 		switch ( origin[ 0 ] ) {

   938 			case "top": y = 0; break;

   939 			case "middle": y = 0.5; break;

   940 			case "bottom": y = 1; break;

   941 			default: y = origin[ 0 ] / original.height;

   942 		}

   943 		switch ( origin[ 1 ] ) {

   944 			case "left": x = 0; break;

   945 			case "center": x = 0.5; break;

   946 			case "right": x = 1; break;

   947 			default: x = origin[ 1 ] / original.width;

   948 		}

   949 		return {

   950 			x: x,

   951 			y: y

   952 		};

   953 	},

   954 

   955 	// Wraps the element around a wrapper that copies position properties

   956 	createWrapper: function( element ) {

   957 

   958 		// if the element is already wrapped, return it

   959 		if ( element.parent().is( ".ui-effects-wrapper" )) {

   960 			return element.parent();

   961 		}

   962 

   963 		// wrap the element

   964 		var props = {

   965 				width: element.outerWidth(true),

   966 				height: element.outerHeight(true),

   967 				"float": element.css( "float" )

   968 			},

   969 			wrapper = $( "<div></div>" )

   970 				.addClass( "ui-effects-wrapper" )

   971 				.css({

   972 					fontSize: "100%",

   973 					background: "transparent",

   974 					border: "none",

   975 					margin: 0,

   976 					padding: 0

   977 				}),

   978 			// Store the size in case width/height are defined in % - Fixes #5245

   979 			size = {

   980 				width: element.width(),

   981 				height: element.height()

   982 			},

   983 			active = document.activeElement;

   984 

   985 		// support: Firefox

   986 		// Firefox incorrectly exposes anonymous content

   987 		// https://bugzilla.mozilla.org/show_bug.cgi?id=561664

   988 		try {

   989 			active.id;

   990 		} catch( e ) {

   991 			active = document.body;

   992 		}

   993 

   994 		element.wrap( wrapper );

   995 

   996 		// Fixes #7595 - Elements lose focus when wrapped.

   997 		if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {

   998 			$( active ).focus();

   999 		}

  1000 

  1001 		wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element

  1002 

  1003 		// transfer positioning properties to the wrapper

  1004 		if ( element.css( "position" ) === "static" ) {

  1005 			wrapper.css({ position: "relative" });

  1006 			element.css({ position: "relative" });

  1007 		} else {

  1008 			$.extend( props, {

  1009 				position: element.css( "position" ),

  1010 				zIndex: element.css( "z-index" )

  1011 			});

  1012 			$.each([ "top", "left", "bottom", "right" ], function(i, pos) {

  1013 				props[ pos ] = element.css( pos );

  1014 				if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {

  1015 					props[ pos ] = "auto";

  1016 				}

  1017 			});

  1018 			element.css({

  1019 				position: "relative",

  1020 				top: 0,

  1021 				left: 0,

  1022 				right: "auto",

  1023 				bottom: "auto"

  1024 			});

  1025 		}

  1026 		element.css(size);

  1027 

  1028 		return wrapper.css( props ).show();

  1029 	},

  1030 

  1031 	removeWrapper: function( element ) {

  1032 		var active = document.activeElement;

  1033 

  1034 		if ( element.parent().is( ".ui-effects-wrapper" ) ) {

  1035 			element.parent().replaceWith( element );

  1036 

  1037 			// Fixes #7595 - Elements lose focus when wrapped.

  1038 			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {

  1039 				$( active ).focus();

  1040 			}

  1041 		}

  1042 

  1043 

  1044 		return element;

  1045 	},

  1046 

  1047 	setTransition: function( element, list, factor, value ) {

  1048 		value = value || {};

  1049 		$.each( list, function( i, x ) {

  1050 			var unit = element.cssUnit( x );

  1051 			if ( unit[ 0 ] > 0 ) {

  1052 				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];

  1053 			}

  1054 		});

  1055 		return value;

  1056 	}

  1057 });

  1058 

  1059 // return an effect options object for the given parameters:

  1060 function _normalizeArguments( effect, options, speed, callback ) {

  1061 

  1062 	// allow passing all options as the first parameter

  1063 	if ( $.isPlainObject( effect ) ) {

  1064 		options = effect;

  1065 		effect = effect.effect;

  1066 	}

  1067 

  1068 	// convert to an object

  1069 	effect = { effect: effect };

  1070 

  1071 	// catch (effect, null, ...)

  1072 	if ( options == null ) {

  1073 		options = {};

  1074 	}

  1075 

  1076 	// catch (effect, callback)

  1077 	if ( $.isFunction( options ) ) {

  1078 		callback = options;

  1079 		speed = null;

  1080 		options = {};

  1081 	}

  1082 

  1083 	// catch (effect, speed, ?)

  1084 	if ( typeof options === "number" || $.fx.speeds[ options ] ) {

  1085 		callback = speed;

  1086 		speed = options;

  1087 		options = {};

  1088 	}

  1089 

  1090 	// catch (effect, options, callback)

  1091 	if ( $.isFunction( speed ) ) {

  1092 		callback = speed;

  1093 		speed = null;

  1094 	}

  1095 

  1096 	// add options to effect

  1097 	if ( options ) {

  1098 		$.extend( effect, options );

  1099 	}

  1100 

  1101 	speed = speed || options.duration;

  1102 	effect.duration = $.fx.off ? 0 :

  1103 		typeof speed === "number" ? speed :

  1104 		speed in $.fx.speeds ? $.fx.speeds[ speed ] :

  1105 		$.fx.speeds._default;

  1106 

  1107 	effect.complete = callback || options.complete;

  1108 

  1109 	return effect;

  1110 }

  1111 

  1112 function standardAnimationOption( option ) {

  1113 	// Valid standard speeds (nothing, number, named speed)

  1114 	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {

  1115 		return true;

  1116 	}

  1117 

  1118 	// Invalid strings - treat as "normal" speed

  1119 	if ( typeof option === "string" && !$.effects.effect[ option ] ) {

  1120 		return true;

  1121 	}

  1122 

  1123 	// Complete callback

  1124 	if ( $.isFunction( option ) ) {

  1125 		return true;

  1126 	}

  1127 

  1128 	// Options hash (but not naming an effect)

  1129 	if ( typeof option === "object" && !option.effect ) {

  1130 		return true;

  1131 	}

  1132 

  1133 	// Didn't match any standard API

  1134 	return false;

  1135 }