/*!

 * jQuery UI Effects 1.13.3

 * https://jqueryui.com

 *

 * Copyright OpenJS Foundation and other contributors

 * Released under the MIT license.

 * https://jquery.org/license

 */

//>>label: Effects Core

//>>group: Effects

/* eslint-disable max-len */

//>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.

/* eslint-enable max-len */

//>>docs: https://api.jqueryui.com/category/effects-core/

//>>demos: https://jqueryui.com/effect/

( function( factory ) {

	"use strict";

	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./jquery-var-for-color",

			"./vendor/jquery-color/jquery.color",

			"./version"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

var dataSpace = "ui-effects-",

	dataSpaceStyle = "ui-effects-style",

	dataSpaceAnimated = "ui-effects-animated";

$.effects = {

	effect: {}

};

/******************************************************************************/

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

/******************************************************************************/

( function() {

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

	shorthandStyles = {

		border: 1,

		borderBottom: 1,

		borderColor: 1,

		borderLeft: 1,

		borderRight: 1,

		borderTop: 1,

		borderWidth: 1,

		margin: 1,

		padding: 1

	};

$.each(

	[ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ],

	function( _, prop ) {

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

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

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

				fx.setAttr = true;

			}

		};

	}

);

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,

		styles = {};

	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 ];

			}

		}

	// Support: Opera, IE <9

	} else {

		for ( key in style ) {

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

				styles[ key ] = style[ key ];

			}

		}

	}

	return styles;

}

function styleDifference( oldStyle, newStyle ) {

	var diff = {},

		name, value;

	for ( name in newStyle ) {

		value = newStyle[ name ];

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

			if ( !shorthandStyles[ name ] ) {

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

					diff[ name ] = value;

				}

			}

		}

	}

	return diff;

}

// Support: jQuery <1.8

if ( !$.fn.addBack ) {

	$.fn.addBack = function( selector ) {

		return this.add( selector == null ?

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

		);

	};

}

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

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

	return this.queue( function() {

		var animated = $( this ),

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

			applyClassChange,

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

		// Map the animated objects to store the original styles.

		allAnimations = allAnimations.map( function() {

			var el = $( this );

			return {

				el: el,

				start: getElementStyles( this )

			};

		} );

		// Apply class change

		applyClassChange = function() {

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

				if ( value[ action ] ) {

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

				}

			} );

		};

		applyClassChange();

		// Map all animated objects again - calculate new styles and diff

		allAnimations = allAnimations.map( function() {

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

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

			return this;

		} );

		// Apply original class

		animated.attr( "class", baseClass );

		// Map all animated objects again - this time collecting a promise

		allAnimations = allAnimations.map( function() {

			var styleInfo = this,

				dfd = $.Deferred(),

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

					queue: false,

					complete: function() {

						dfd.resolve( styleInfo );

					}

				} );

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

			return dfd.promise();

		} );

		// Once all animations have completed:

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

			// Set the final class

			applyClassChange();

			// For each animated element,

			// clear all css properties that were animated

			$.each( arguments, function() {

				var el = this.el;

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

					el.css( key, "" );

				} );

			} );

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

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

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

		} );

	} );

};

$.fn.extend( {

	addClass: ( function( orig ) {

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

			return speed ?

				$.effects.animateClass.call( this,

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

				orig.apply( this, arguments );

		};

	} )( $.fn.addClass ),

	removeClass: ( function( orig ) {

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

			return arguments.length > 1 ?

				$.effects.animateClass.call( this,

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

				orig.apply( this, arguments );

		};

	} )( $.fn.removeClass ),

	toggleClass: ( function( orig ) {

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

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

				if ( !speed ) {

					// Without speed parameter

					return orig.apply( this, arguments );

				} else {

					return $.effects.animateClass.call( this,

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

						speed, easing, callback );

				}

			} else {

				// Without force parameter

				return $.effects.animateClass.call( this,

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

			}

		};

	} )( $.fn.toggleClass ),

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

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

			add: add,

			remove: remove

		}, speed, easing, callback );

	}

} );

} )();

/******************************************************************************/

/*********************************** EFFECTS **********************************/

/******************************************************************************/

( function() {

if ( $.expr && $.expr.pseudos && $.expr.pseudos.animated ) {

	$.expr.pseudos.animated = ( function( orig ) {

		return function( elem ) {

			return !!$( elem ).data( dataSpaceAnimated ) || orig( elem );

		};

	} )( $.expr.pseudos.animated );

}

if ( $.uiBackCompat !== false ) {

	$.extend( $.effects, {

		// Saves a set of properties in a data storage

		save: function( element, set ) {

			var i = 0, length = set.length;

			for ( ; i < length; i++ ) {

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

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

				}

			}

		},

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

		restore: function( element, set ) {

			var val, i = 0, length = set.length;

			for ( ; i < length; i++ ) {

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

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

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

				}

			}

		},

		setMode: function( el, mode ) {

			if ( mode === "toggle" ) {

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

			}

			return mode;

		},

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

		createWrapper: function( element ) {

			// If the element is already wrapped, return it

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

				return element.parent();

			}

			// Wrap the element

			var props = {

					width: element.outerWidth( true ),

					height: element.outerHeight( true ),

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

				},

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

					.addClass( "ui-effects-wrapper" )

					.css( {

						fontSize: "100%",

						background: "transparent",

						border: "none",

						margin: 0,

						padding: 0

					} ),

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

				size = {

					width: element.width(),

					height: element.height()

				},

				active = document.activeElement;

			// 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;

			}

			element.wrap( wrapper );

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

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