enmi-conf.org: comparison wp/wp-includes/js/jquery/ui/effect.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/jquery/ui/effect.js

changeset 19	3d72ae0968f4
parent 18	be944660c56a
child 21	48c4eec2b7e6

equal deleted inserted replaced

-:be944660c56a
+:3d72ae0968f4
 /*!
-* jQuery UI Effects 1.12.1
+* jQuery UI Effects 1.13.1
 * http://jqueryui.com
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 */
 //>>label: Effects Core
 //>>group: Effects
-// jscs:disable maximumLineLength
+/* eslint-disable max-len */
 //>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
-// jscs:enable maximumLineLength
+/* eslint-enable max-len */
 //>>docs: http://api.jqueryui.com/category/effects-core/
 //>>demos: http://jqueryui.com/effect/
 ( function( factory ) {
+	"use strict";
 	if ( typeof define === "function" && define.amd ) {
 		// AMD. Register as an anonymous module.
 		define( [ "jquery" ], factory );
 	} else {
 		// Browser globals
 		factory( jQuery );
 	}
-}( function( $ ) {
+} )( function( $ ) {
+"use strict";
 // Include version.js
 $.ui = $.ui || {};
-$.ui.version = "1.12.1";
+$.ui.version = "1.13.1";
-var dataSpace = "ui-effects-",
+// Source: jquery-var-for-color.js
-	dataSpaceStyle = "ui-effects-style",
+// Create a local jQuery because jQuery Color relies on it and the
-	dataSpaceAnimated = "ui-effects-animated",
+// global may not exist with AMD and a custom build (#10199).
+// This module is a noop if used as a regular AMD module.
-	// Create a local jQuery because jQuery Color relies on it and the
+// eslint-disable-next-line no-unused-vars
-	// global may not exist with AMD and a custom build (#10199)
+var jQuery = $;
-	jQuery = $;
-$.effects = {
-	effect: {}
-};
 /*!
-* jQuery Color Animations v2.1.2
+* jQuery Color Animations v2.2.0
 * https://github.com/jquery/jquery-color
 *
-* Copyright 2014 jQuery Foundation and other contributors
+* Copyright OpenJS Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
-* Date: Wed Jan 16 08:47:09 2013 -0600
+* Date: Sun May 10 09:02:36 2020 +0200
 */
-( function( jQuery, undefined ) {
 	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " +
 		"borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
-	// Plusequals test for += 100 -= 100
+	class2type = {},
+	toString = class2type.toString,
+	// plusequals test for += 100 -= 100
 	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
-	// A set of RE's that can match strings and generate color tuples.
+	// 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[ 4 ]
 				];
 			}
 		}, {
-			// This regex ignores A-F because it's compared against an already lowercased string
+			// 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})/,
+			re: /#([a-f0-9]{2})([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 )
+					parseInt( execResult[ 3 ], 16 ),
+					execResult[ 4 ] ?
+						( parseInt( execResult[ 4 ], 16 ) / 255 ).toFixed( 2 ) :
+						1
 				];
 			}
 		}, {
-			// This regex ignores A-F because it's compared against an already lowercased string
+			// this regex ignores A-F because it's compared against an already lowercased string
-			re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
+			re: /#([a-f0-9])([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 )
+					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ),
+					execResult[ 4 ] ?
+						( parseInt( execResult[ 4 ] + execResult[ 4 ], 16 ) / 255 )
+							.toFixed( 2 ) :
+						1
 				];
 			}
 		}, {
 			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
 			space: "hsla",
 					execResult[ 4 ]
 				];
 			}
 		} ],
-	// JQuery.Color( )
+	// jQuery.Color( )
 	color = jQuery.Color = function( color, green, blue, alpha ) {
 		return new jQuery.Color.fn.parse( color, green, blue, alpha );
 	},
 	spaces = {
 		rgba: {
 			floor: true
 		}
 	},
 	support = color.support = {},
-	// Element for support tests
+	// element for support tests
 	supportElem = jQuery( "<p>" )[ 0 ],
-	// Colors = jQuery.Color.names
+	// colors = jQuery.Color.names
 	colors,
-	// Local aliases of functions called often
+	// local aliases of functions called often
 	each = jQuery.each;
-// Determine rgba support immediately
+// 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
+// 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
 	};
 } );
+// Populate the class2type map
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
+	function( _i, name ) {
+		class2type[ "[object " + name + "]" ] = name.toLowerCase();
+	} );
+function getType( obj ) {
+	if ( obj == null ) {
+		return obj + "";
+	}
+	return typeof obj === "object" ?
+		class2type[ toString.call( obj ) ] || "object" :
+		typeof obj;
+}
 function clamp( value, prop, allowEmpty ) {
 	var type = propTypes[ prop.type ] || {};
 	if ( value == null ) {
 		return ( allowEmpty || !prop.def ) ? null : prop.def;
 		return prop.def;
 	}
 	if ( type.mod ) {
-		// We add mod before modding to make sure that negatives values
+		// 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
+	// for now all property types without mod have min and max
-	return 0 > value ? 0 : type.max < value ? type.max : value;
+	return Math.min( type.max, Math.max( 0, value ) );
 }
 function stringParse( string ) {
 	var inst = color(),
 		rgba = inst._rgba = [];
 	string = string.toLowerCase();
-	each( stringParsers, function( i, parser ) {
+	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
+			// 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
+			// 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
+		// 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
+	// named colors
 	return colors[ string ];
 }
 color.fn = jQuery.extend( color.prototype, {
 	parse: function( red, green, blue, alpha ) {
 			red = jQuery( red ).css( green );
 			green = undefined;
 		}
 		var inst = this,
-			type = jQuery.type( red ),
+			type = getType( red ),
 			rgba = this._rgba = [];
-		// More than 1 argument specified - assume ( red, green, blue, alpha )
+		// 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 ) {
+			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 ) {
+				each( spaces, function( _spaceName, space ) {
 					if ( red[ space.cache ] ) {
 						inst[ space.cache ] = red[ space.cache ].slice();
 					}
 				} );
 			} else {
-				each( spaces, function( spaceName, space ) {
+				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 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 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.
+						// 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?
+					// everything defined but alpha?
-					if ( inst[ cache ] &&
+					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
-							jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
+						// use the default of 1
-						// Use the default of 1
+						if ( inst[ cache ][ 3 ] == null ) {
-						inst[ cache ][ 3 ] = 1;
+							inst[ cache ][ 3 ] = 1;
+						}
 						if ( space.from ) {
 							inst._rgba = space.from( inst[ cache ] );
 						}
 					}
 				} );
 			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 ) {
+		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 null, don't override start value
 			if ( endValue === null ) {
 				return;
 			}
-			// If null - use end
+			// if null - use end
 			if ( startValue === null ) {
 				result[ index ] = endValue;
 			} else {
 				if ( type.mod ) {
 					if ( endValue - startValue > type.mod / 2 ) {
 		} );
 		return this[ spaceName ]( result );
 	},
 	blend: function( opaque ) {
-		// If we are already opaque - return ourself
+		// if we are already opaque - return ourself
 		if ( this._rgba[ 3 ] === 1 ) {
 			return this;
 		}
 		var rgb = this._rgba.slice(),
 		} ) );
 	},
 	toRgbaString: function() {
 		var prefix = "rgba(",
 			rgba = jQuery.map( this._rgba, function( v, i ) {
-				return v == null ? ( i > 2 ? 1 : 0 ) : v;
+				if ( v != null ) {
+					return v;
+				}
+				return i > 2 ? 1 : 0;
 			} );
 		if ( rgba[ 3 ] === 1 ) {
 			rgba.pop();
 			prefix = "rgb(";
 			hsla = jQuery.map( this.hsla(), function( v, i ) {
 				if ( v == null ) {
 					v = i > 2 ? 1 : 0;
 				}
-				// Catch 1 and 2
+				// catch 1 and 2
 				if ( i && i < 3 ) {
 					v = Math.round( v * 100 ) + "%";
 				}
 				return v;
 			} );
 			rgba.push( ~~( alpha * 255 ) );
 		}
 		return "#" + jQuery.map( rgba, function( v ) {
-			// Default to 0 when nulls exist
+			// default to 0 when nulls exist
 			v = ( v || 0 ).toString( 16 );
 			return v.length === 1 ? "0" + v : v;
 		} ).join( "" );
 	},
 	toString: function() {
 		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
 	}
 } );
 color.fn.parse.prototype = color.fn;
-// Hsla conversions adapted from:
+// hsla conversions adapted from:
 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
 function hue2rgb( p, q, h ) {
 	h = ( h + 1 ) % 1;
 	if ( h * 6 < 1 ) {
 		h = ( 60 * ( b - r ) / diff ) + 120;
 	} else {
 		h = ( 60 * ( r - g ) / diff ) + 240;
 	}
-	// Chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
+	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
 	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
 	if ( diff === 0 ) {
 		s = 0;
 	} else if ( l <= 0.5 ) {
 		s = diff / add;
 		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
 		a
 	];
 };
 each( spaces, function( spaceName, space ) {
 	var props = space.props,
 		cache = space.cache,
 		to = space.to,
 		from = space.from;
-	// Makes rgba() and hsla()
+	// makes rgba() and hsla()
 	color.fn[ spaceName ] = function( value ) {
-		// Generate a cache for this space if it doesn't exist
+		// generate a cache for this space if it doesn't exist
 		if ( to && !this[ cache ] ) {
 			this[ cache ] = to( this._rgba );
 		}
 		if ( value === undefined ) {
 			return this[ cache ].slice();
 		}
 		var ret,
-			type = jQuery.type( value ),
+			type = getType( value ),
 			arr = ( type === "array" || type === "object" ) ? value : arguments,
 			local = this[ cache ].slice();
 		each( props, function( key, prop ) {
 			var val = arr[ type === "object" ? key : prop.idx ];
 		} else {
 			return color( local );
 		}
 	};
-	// Makes red() green() blue() alpha() hue() saturation() lightness()
+	// makes red() green() blue() alpha() hue() saturation() lightness()
 	each( props, function( key, prop ) {
-		// Alpha is included in more than one space
+		// alpha is included in more than one space
 		if ( color.fn[ key ] ) {
 			return;
 		}
 		color.fn[ key ] = function( value ) {
-			var vtype = jQuery.type( value ),
+			var local, cur, match, fn,
-				fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
+				vtype = getType( value );
-				local = this[ fn ](),
-				cur = local[ prop.idx ],
+			if ( key === "alpha" ) {
-				match;
+				fn = this._hsla ? "hsla" : "rgba";
+			} else {
+				fn = spaceName;
+			}
+			local = this[ fn ]();
+			cur = local[ prop.idx ];
 			if ( vtype === "undefined" ) {
 				return cur;
 			}
 			if ( vtype === "function" ) {
 				value = value.call( this, cur );
-				vtype = jQuery.type( value );
+				vtype = getType( value );
 			}
 			if ( value == null && prop.empty ) {
 				return this;
 			}
 			if ( vtype === "string" ) {
 			return this[ fn ]( local );
 		};
 	} );
 } );
-// Add cssHook and .fx.step function for each named hook.
+// add cssHook and .fx.step function for each named hook.
 // accept a space separated string of properties
 color.hook = function( hook ) {
 	var hooks = hook.split( " " );
-	each( hooks, function( i, hook ) {
+	each( hooks, function( _i, hook ) {
 		jQuery.cssHooks[ hook ] = {
 			set: function( elem, value ) {
 				var parsed, curElem,
 					backgroundColor = "";
-				if ( value !== "transparent" && ( jQuery.type( value ) !== "string" ||
+				if ( value !== "transparent" && ( getType( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
-						( parsed = stringParse( value ) ) ) ) {
 					value = color( parsed || value );
 					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
 						curElem = hook === "backgroundColor" ? elem.parentNode : elem;
 						while (
 							( backgroundColor === "" || backgroundColor === "transparent" ) &&
 				}
 				try {
 					elem.style[ hook ] = value;
 				} catch ( e ) {
-					// Wrapped to prevent IE from throwing errors on "invalid" values like
+					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
-					// 'auto' or 'inherit'
 				}
 			}
 		};
 		jQuery.fx.step[ hook ] = function( fx ) {
 			if ( !fx.colorInit ) {
 jQuery.cssHooks.borderColor = {
 	expand: function( value ) {
 		var expanded = {};
-		each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
+		each( [ "Top", "Right", "Bottom", "Left" ], function( _i, part ) {
 			expanded[ "border" + part + "Color" ] = value;
 		} );
 		return expanded;
 	}
 };
 	transparent: [ null, null, null, 0 ],
 	_default: "#ffffff"
 };
-} )( jQuery );
+var dataSpace = "ui-effects-",
+	dataSpaceStyle = "ui-effects-style",
+	dataSpaceAnimated = "ui-effects-animated";
+$.effects = {
+	effect: {}
+};
 /******************************************************************************/
 /****************************** CLASS ANIMATIONS ******************************/
 /******************************************************************************/
 ( function() {
 			}
 		};
 	}
 );
+function camelCase( string ) {
+	return string.replace( /-([\da-z])/gi, function( all, letter ) {
+		return letter.toUpperCase();
+	} );
+}
 function getElementStyles( elem ) {
 	var key, len,
 		style = elem.ownerDocument.defaultView ?
 			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
 			elem.currentStyle,
 	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
 		len = style.length;
 		while ( len-- ) {
 			key = style[ len ];
 			if ( typeof style[ key ] === "string" ) {
-				styles[ $.camelCase( key ) ] = style[ key ];
+				styles[ camelCase( key ) ] = style[ key ];
 			}
 		}
-	// Support: Opera, IE <9
+		// Support: Opera, IE <9
 	} else {
 		for ( key in style ) {
 			if ( typeof style[ key ] === "string" ) {
 				styles[ key ] = style[ key ];
 			}
 /*********************************** EFFECTS **********************************/
 /******************************************************************************/
 ( function() {
-if ( $.expr && $.expr.filters && $.expr.filters.animated ) {
+if ( $.expr && $.expr.pseudos && $.expr.pseudos.animated ) {
-	$.expr.filters.animated = ( function( orig ) {
+	$.expr.pseudos.animated = ( function( orig ) {
 		return function( elem ) {
 			return !!$( elem ).data( dataSpaceAnimated ) || orig( elem );
 		};
-	} )( $.expr.filters.animated );
+	} )( $.expr.pseudos.animated );
 }
 if ( $.uiBackCompat !== false ) {
 	$.extend( $.effects, {
 			// Support: Firefox
 			// Firefox incorrectly exposes anonymous content
 			// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
 			try {
+				// eslint-disable-next-line no-unused-expressions
 				active.id;
 			} catch ( e ) {
 				active = document.body;
 			}
 		}
 	} );
 }
 $.extend( $.effects, {
-	version: "1.12.1",
+	version: "1.13.1",
 	define: function( name, mode, effect ) {
 		if ( !effect ) {
 			effect = mode;
 			mode = "effect";
 	// Translates a [top,left] array into a baseline value
 	getBaseline: function( origin, original ) {
 		var y, x;
 		switch ( origin[ 0 ] ) {
-		case "top":
+			case "top":
-			y = 0;
+				y = 0;
-			break;
+				break;
-		case "middle":
+			case "middle":
-			y = 0.5;
+				y = 0.5;
-			break;
+				break;
-		case "bottom":
+			case "bottom":
-			y = 1;
+				y = 1;
-			break;
+				break;
-		default:
+			default:
-			y = origin[ 0 ] / original.height;
+				y = origin[ 0 ] / original.height;
 		}
 		switch ( origin[ 1 ] ) {
-		case "left":
+			case "left":
-			x = 0;
+				x = 0;
-			break;
+				break;
-		case "center":
+			case "center":
-			x = 0.5;
+				x = 0.5;
-			break;
+				break;
-		case "right":
+			case "right":
-			x = 1;
+				x = 1;
-			break;
+				break;
-		default:
+			default:
-			x = origin[ 1 ] / original.width;
+				x = origin[ 1 ] / original.width;
 		}
 		return {
 			x: x,
 			y: y
 			marginTop: element.css( "marginTop" ),
 			marginBottom: element.css( "marginBottom" ),
 			marginLeft: element.css( "marginLeft" ),
 			marginRight: element.css( "marginRight" )
 		} )
-		.outerWidth( element.outerWidth() )
+			.outerWidth( element.outerWidth() )
-		.outerHeight( element.outerHeight() );
+			.outerHeight( element.outerHeight() );
 		if ( /^(static|relative)/.test( cssPosition ) ) {
 			cssPosition = "absolute";
 			placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( {
 				marginBottom: element.css( "marginBottom" ),
 				marginLeft: element.css( "marginLeft" ),
 				marginRight: element.css( "marginRight" ),
 				"float": element.css( "float" )
 			} )
-			.outerWidth( element.outerWidth() )
+				.outerWidth( element.outerWidth() )
-			.outerHeight( element.outerHeight() )
+				.outerHeight( element.outerHeight() )
-			.addClass( "ui-effects-placeholder" );
+				.addClass( "ui-effects-placeholder" );
 			element.data( dataSpace + "placeholder", placeholder );
 		}
 		element.css( {
 		return placeholder;
 	},
 	removePlaceholder: function( element ) {
 		var dataKey = dataSpace + "placeholder",
-				placeholder = element.data( dataKey );
+			placeholder = element.data( dataKey );
 		if ( placeholder ) {
 			placeholder.remove();
 			element.removeData( dataKey );
 		}
 	if ( options == null ) {
 		options = {};
 	}
 	// Catch (effect, callback)
-	if ( $.isFunction( options ) ) {
+	if ( typeof options === "function" ) {
 		callback = options;
 		speed = null;
 		options = {};
 	}
 		speed = options;
 		options = {};
 	}
 	// Catch (effect, options, callback)
-	if ( $.isFunction( speed ) ) {
+	if ( typeof speed === "function" ) {
 		callback = speed;
 		speed = null;
 	}
 	// Add options to effect
 	}
 	speed = speed || options.duration;
 	effect.duration = $.fx.off ? 0 :
 		typeof speed === "number" ? speed :
-		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
+			speed in $.fx.speeds ? $.fx.speeds[ speed ] :
-		$.fx.speeds._default;
+				$.fx.speeds._default;
 	effect.complete = callback || options.complete;
 	return effect;
 }
 	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
 		return true;
 	}
 	// Complete callback
-	if ( $.isFunction( option ) ) {
+	if ( typeof option === "function" ) {
 		return true;
 	}
 	// Options hash (but not naming an effect)
 	if ( typeof option === "object" && !option.effect ) {
 			modes = [],
 			prefilter = function( next ) {
 				var el = $( this ),
 					normalizedMode = $.effects.mode( el, mode ) || defaultMode;
-				// Sentinel for duck-punching the :animated psuedo-selector
+				// Sentinel for duck-punching the :animated pseudo-selector
 				el.data( dataSpaceAnimated, true );
 				// Save effect mode for later use,
 				// we can't just call $.effects.mode again later,
 				// as the .show() below destroys the initial state
 				modes.push( normalizedMode );
-				// See $.uiBackCompat inside of run() for removal of defaultMode in 1.13
+				// See $.uiBackCompat inside of run() for removal of defaultMode in 1.14
 				if ( defaultMode && ( normalizedMode === "show" ||
-						( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) {
+					( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) {
 					el.show();
 				}
 				if ( !defaultMode || normalizedMode !== "none" ) {
 					$.effects.saveStyle( el );
 				}
-				if ( $.isFunction( next ) ) {
+				if ( typeof next === "function" ) {
 					next();
 				}
 			};
 		if ( $.fx.off || !effectMethod ) {
 				done();
 			}
 			function done() {
-				if ( $.isFunction( complete ) ) {
+				if ( typeof complete === "function" ) {
 					complete.call( elem[ 0 ] );
 				}
-				if ( $.isFunction( next ) ) {
+				if ( typeof next === "function" ) {
 					next();
 				}
 			}
 			// Override mode option on a per element basis,
 				left: endPosition.left - fixLeft,
 				height: target.innerHeight(),
 				width: target.innerWidth()
 			},
 			startPosition = element.offset(),
-			transfer = $( "<div class='ui-effects-transfer'></div>" )
+			transfer = $( "<div class='ui-effects-transfer'></div>" );
-				.appendTo( "body" )
-				.addClass( options.className )
+		transfer
-				.css( {
+			.appendTo( "body" )
-					top: startPosition.top - fixTop,
+			.addClass( options.className )
-					left: startPosition.left - fixLeft,
+			.css( {
-					height: element.innerHeight(),
+				top: startPosition.top - fixTop,
-					width: element.innerWidth(),
+				left: startPosition.left - fixLeft,
-					position: targetFixed ? "fixed" : "absolute"
+				height: element.innerHeight(),
-				} )
+				width: element.innerWidth(),
-				.animate( animation, options.duration, options.easing, function() {
+				position: targetFixed ? "fixed" : "absolute"
-					transfer.remove();
+			} )
-					if ( $.isFunction( done ) ) {
+			.animate( animation, options.duration, options.easing, function() {
-						done();
+				transfer.remove();
-					}
+				if ( typeof done === "function" ) {
-				} );
+					done();
+				}
+			} );
 	}
 } );
 function parseClip( str, element ) {
-		var outerWidth = element.outerWidth(),
+	var outerWidth = element.outerWidth(),
-			outerHeight = element.outerHeight(),
+		outerHeight = element.outerHeight(),
-			clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/,
+		clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/,
-			values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ];
+		values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ];
-		return {
+	return {
-			top: parseFloat( values[ 1 ] ) || 0,
+		top: parseFloat( values[ 1 ] ) || 0,
-			right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ),
+		right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ),
-			bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ),
+		bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ),
-			left: parseFloat( values[ 4 ] ) || 0
+		left: parseFloat( values[ 4 ] ) || 0
-		};
+	};
 }
 $.fx.step.clip = function( fx ) {
 	if ( !fx.clipInit ) {
 		fx.start = $( fx.elem ).cssClip();
 } )();
 return $.effects;
-} ) );
+} );

enmi-conf.org