https://dw-f.jp/service/res/design/CRFoundation/js/jQuery/jquery-ui.min.js?1790309106

161
162
163	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " +
164		"borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
165
166	class2type = {},
167	toString = class2type.toString,
168
169	// plusequals test for += 100 -= 100
170	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
171
172	// a set of RE's that can match strings and generate color tuples.
173	stringParsers = [ {
174			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
175			parse: function( execResult ) {
176				return [
177					execResult[ 1 ],
178					execResult[ 2 ],
179					execResult[ 3 ],
180					execResult[ 4 ]
181				];
182			}
183		}, {
184			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
185			parse: function( execResult ) {
186				return [
187					execResult[ 1 ] * 2.55,
188					execResult[ 2 ] * 2.55,
189					execResult[ 3 ] * 2.55,
190					execResult[ 4 ]
191				];
192			}
193		}, {
194
195			// this regex ignores A-F because it's compared against an already lowercased string
196			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?/,
197			parse: function( execResult ) {
198				return [
199					parseInt( execResult[ 1 ], 16 ),
200					parseInt( execResult[ 2 ], 16 ),
201					parseInt( execResult[ 3 ], 16 ),
202					execResult[ 4 ] ?
203						( parseInt( execResult[ 4 ], 16 ) / 255 ).toFixed( 2 ) :
204						1
205				];
206			}
207		}, {
208
209			// this regex ignores A-F because it's compared against an already lowercased string
210			re: /#([a-f0-9])([a-f0-9])([a-f0-9])([a-f0-9])?/,
211			parse: function( execResult ) {
212				return [
213					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
214					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
215					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ),
216					execResult[ 4 ] ?
217						( parseInt( execResult[ 4 ] + execResult[ 4 ], 16 ) / 255 )
218							.toFixed( 2 ) :
219						1
220				];
221			}
222		}, {
223			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
224			space: "hsla",
225			parse: function( execResult ) {
226				return [
227					execResult[ 1 ],
228					execResult[ 2 ] / 100,
229					execResult[ 3 ] / 100,
230					execResult[ 4 ]
231				];
232			}
233		} ],
234
235	// jQuery.Color( )
236	color = jQuery.Color = function( color, green, blue, alpha ) {
237		return new jQuery.Color.fn.parse( color, green, blue, alpha );
238	},
239	spaces = {
240		rgba: {
241			props: {
242				red: {
243					idx: 0,
244					type: "byte"
245				},
246				green: {
247					idx: 1,
248					type: "byte"
249				},
250				blue: {
251					idx: 2,
252					type: "byte"
253				}
254			}
255		},
256
257		hsla: {
258			props: {
259				hue: {
260					idx: 0,
261					type: "degrees"
262				},
263				saturation: {
264					idx: 1,
265					type: "percent"
266				},
267				lightness: {
268					idx: 2,
269					type: "percent"
270				}
271			}
272		}
273	},
274	propTypes = {
275		"byte": {
276			floor: true,
277			max: 255
278		},
279		"percent": {
280			max: 1
281		},
282		"degrees": {
283			mod: 360,
284			floor: true
285		}
286	},
287
288	// colors = jQuery.Color.names
289	colors,
290
291	// local aliases of functions called often
292	each = jQuery.each;
293
294// define cache name and alpha properties
295// for rgba and hsla spaces
296each( spaces, function( spaceName, space ) {
297	space.cache = "_" + spaceName;
298	space.props.alpha = {
299		idx: 3,
300		type: "percent",
301		def: 1
302	};
303} );
304
305// Populate the class2type map
306jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
307	function( _i, name ) {
308		class2type[ "[object " + name + "]" ] = name.toLowerCase();
309	} );
310
311function getType( obj ) {
312	if ( obj == null ) {
313		return obj + "";
314	}
315
316	return typeof obj === "object" ?
317		class2type[ toString.call( obj ) ] || "object" :
318		typeof obj;
319}
320
321function clamp( value, prop, allowEmpty ) {
322	var type = propTypes[ prop.type ] || {};
323
324	if ( value == null ) {
325		return ( allowEmpty || !prop.def ) ? null : prop.def;
326	}
327
328	// ~~ is an short way of doing floor for positive numbers
329	value = type.floor ? ~~value : parseFloat( value );
330
331	if ( type.mod ) {
332
333		// we add mod before modding to make sure that negatives values
334		// get converted properly: -10 -> 350
335		return ( value + type.mod ) % type.mod;
336	}
337
338	// for now all property types without mod have min and max
339	return Math.min( type.max, Math.max( 0, value ) );
340}
341
342function stringParse( string ) {
343	var inst = color(),
344		rgba = inst._rgba = [];
345
346	string = string.toLowerCase();
347
348	each( stringParsers, function( _i, parser ) {
349		var parsed,
350			match = parser.re.exec( string ),
351			values = match && parser.parse( match ),
352			spaceName = parser.space || "rgba";
353
354		if ( values ) {
355			parsed = inst[ spaceName ]( values );
356
357			// if this was an rgba parse the assignment might happen twice
358			// oh well....
359			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
360			rgba = inst._rgba = parsed._rgba;
361
362			// exit each( stringParsers ) here because we matched
363			return false;
364		}
365	} );
366
367	// Found a stringParser that handled it
368	if ( rgba.length ) {
369
370		// if this came from a parsed string, force "transparent" when alpha is 0
371		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
372		if ( rgba.join() === "0,0,0,0" ) {
373			jQuery.extend( rgba, colors.transparent );
374		}
375		return inst;
376	}
377
378	// named colors
379	return colors[ string ];
380}
381
382color.fn = jQuery.extend( color.prototype, {
383	parse: function( red, green, blue, alpha ) {
384		if ( red === undefined ) {
385			this._rgba = [ null, null, null, null ];
386			return this;
387		}
388		if ( red.jquery || red.nodeType ) {
389			red = jQuery( red ).css( green );
390			green = undefined;
391		}
392
393		var inst = this,
394			type = getType( red ),
395			rgba = this._rgba = [];
396
397		// more than 1 argument specified - assume ( red, green, blue, alpha )
398		if ( green !== undefined ) {
399			red = [ red, green, blue, alpha ];
400			type = "array";
401		}
402
403		if ( type === "string" ) {
404			return this.parse( stringParse( red ) || colors._default );
405		}
406
407		if ( type === "array" ) {
408			each( spaces.rgba.props, function( _key, prop ) {
409				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
410			} );
411			return this;
412		}
413
414		if ( type === "object" ) {
415			if ( red instanceof color ) {
416				each( spaces, function( _spaceName, space ) {
417					if ( red[ space.cache ] ) {
418						inst[ space.cache ] = red[ space.cache ].slice();
419					}
420				} );
421			} else {
422				each( spaces, function( _spaceName, space ) {
423					var cache = space.cache;
424					each( space.props, function( key, prop ) {
425
426						// if the cache doesn't exist, and we know how to convert
427						if ( !inst[ cache ] && space.to ) {
428
429							// if the value was null, we don't need to copy it
430							// if the key was alpha, we don't need to copy it either
431							if ( key === "alpha" || red[ key ] == null ) {
432								return;
433							}
434							inst[ cache ] = space.to( inst._rgba );
435						}
436
437						// this is the only case where we allow nulls for ALL properties.
438						// call clamp with alwaysAllowEmpty
439						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
440					} );
441
442					// everything defined but alpha?
443					if ( inst[ cache ] && jQuery.inArray(
444						null,
445						inst[ cache ].slice( 0, 3 )
446					) < 0 ) {
447
448						// use the default of 1
449						if ( inst[ cache ][ 3 ] == null ) {
450							inst[ cache ][ 3 ] = 1;
451						}
452
453						if ( space.from ) {
454							inst._rgba = space.from( inst[ cache ] );
455						}
456					}
457				} );
458			}
459			return this;
460		}
461	},
462	is: function( compare ) {
463		var is = color( compare ),
464			same = true,
465			inst = this;
466
467		each( spaces, function( _, space ) {
468			var localCache,
469				isCache = is[ space.cache ];
470			if ( isCache ) {
471				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
472				each( space.props, function( _, prop ) {
473					if ( isCache[ prop.idx ] != null ) {
474						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
475						return same;
476					}
477				} );
478			}
479			return same;
480		} );
481		return same;
482	},
483	_space: function() {
484		var used = [],
485			inst = this;
486		each( spaces, function( spaceName, space ) {
487			if ( inst[ space.cache ] ) {
488				used.push( spaceName );
489			}
490		} );
491		return used.pop();
492	},
493	transition: function( other, distance ) {
494		var end = color( other ),
495			spaceName = end._space(),
496			space = spaces[ spaceName ],
497			startColor = this.alpha() === 0 ? color( "transparent" ) : this,
498			start = startColor[ space.cache ] || space.to( startColor._rgba ),
499			result = start.slice();
500
501		end = end[ space.cache ];
502		each( space.props, function( _key, prop ) {
503			var index = prop.idx,
504				startValue = start[ index ],
505				endValue = end[ index ],
506				type = propTypes[ prop.type ] || {};
507
508			// if null, don't override start value
509			if ( endValue === null ) {
510				return;
511			}
512
513			// if null - use end
514			if ( startValue === null ) {
515				result[ index ] = endValue;
516			} else {
517				if ( type.mod ) {
518					if ( endValue - startValue > type.mod / 2 ) {
519						startValue += type.mod;
520					} else if ( startValue - endValue > type.mod / 2 ) {
521						startValue -= type.mod;
522					}
523				}
524				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
525			}
526		} );
527		return this[ spaceName ]( result );
528	},
529	blend: function( opaque ) {
530
531		// if we are already opaque - return ourself
532		if ( this._rgba[ 3 ] === 1 ) {
533			return this;
534		}
535
536		var rgb = this._rgba.slice(),
537			a = rgb.pop(),
538			blend = color( opaque )._rgba;
539
540		return color( jQuery.map( rgb, function( v, i ) {
541			return ( 1 - a ) * blend[ i ] + a * v;
542		} ) );
543	},
544	toRgbaString: function() {
545		var prefix = "rgba(",
546			rgba = jQuery.map( this._rgba, function( v, i ) {
547				if ( v != null ) {
548					return v;
549				}
550				return i > 2 ? 1 : 0;
551			} );
552
553		if ( rgba[ 3 ] === 1 ) {
554			rgba.pop();
555			prefix = "rgb(";
556		}
557
558		return prefix + rgba.join( ", " ) + ")";
559	},
560	toHslaString: function() {
561		var prefix = "hsla(",
562			hsla = jQuery.map( this.hsla(), function( v, i ) {
563				if ( v == null ) {
564					v = i > 2 ? 1 : 0;
565				}
566
567				// catch 1 and 2
568				if ( i && i < 3 ) {
569					v = Math.round( v * 100 ) + "%";
570				}
571				return v;
572			} );
573
574		if ( hsla[ 3 ] === 1 ) {
575			hsla.pop();
576			prefix = "hsl(";
577		}
578		return prefix + hsla.join( ", " ) + ")";
579	},
580	toHexString: function( includeAlpha ) {
581		var rgba = this._rgba.slice(),
582			alpha = rgba.pop();
583
584		if ( includeAlpha ) {
585			rgba.push( ~~( alpha * 255 ) );
586		}
587
588		return "#" + jQuery.map( rgba, function( v ) {
589
590			// default to 0 when nulls exist
591			return ( "0" + ( v || 0 ).toString( 16 ) ).substr( -2 );
592		} ).join( "" );
593	},
594	toString: function() {
595		return this.toRgbaString();
596	}
597} );
598color.fn.parse.prototype = color.fn;
599
600// hsla conversions adapted from:
601// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
602
603function hue2rgb( p, q, h ) {
604	h = ( h + 1 ) % 1;
605	if ( h * 6 < 1 ) {
606		return p + ( q - p ) * h * 6;
607	}
608	if ( h * 2 < 1 ) {
609		return q;
610	}
611	if ( h * 3 < 2 ) {
612		return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
613	}
614	return p;
615}
616
617spaces.hsla.to = function( rgba ) {
618	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
619		return [ null, null, null, rgba[ 3 ] ];
620	}
621	var r = rgba[ 0 ] / 255,
622		g = rgba[ 1 ] / 255,
623		b = rgba[ 2 ] / 255,
624		a = rgba[ 3 ],
625		max = Math.max( r, g, b ),
626		min = Math.min( r, g, b ),
627		diff = max - min,
628		add = max + min,
629		l = add * 0.5,
630		h, s;
631
632	if ( min === max ) {
633		h = 0;
634	} else if ( r === max ) {
635		h = ( 60 * ( g - b ) / diff ) + 360;
636	} else if ( g === max ) {
637		h = ( 60 * ( b - r ) / diff ) + 120;
638	} else {
639		h = ( 60 * ( r - g ) / diff ) + 240;
640	}
641
642	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
643	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
644	if ( diff === 0 ) {
645		s = 0;
646	} else if ( l <= 0.5 ) {
647		s = diff / add;
648	} else {
649		s = diff / ( 2 - add );
650	}
651	return [ Math.round( h ) % 360, s, l, a == null ? 1 : a ];
652};
653
654spaces.hsla.from = function( hsla ) {
655	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
656		return [ null, null, null, hsla[ 3 ] ];
657	}
658	var h = hsla[ 0 ] / 360,
659		s = hsla[ 1 ],
660		l = hsla[ 2 ],
661		a = hsla[ 3 ],
662		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
663		p = 2 * l - q;
664
665	return [
666		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
667		Math.round( hue2rgb( p, q, h ) * 255 ),
668		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
669		a
670	];
671};
672
673
674each( spaces, function( spaceName, space ) {
675	var props = space.props,
676		cache = space.cache,
677		to = space.to,
678		from = space.from;
679
680	// makes rgba() and hsla()
681	color.fn[ spaceName ] = function( value ) {
682
683		// generate a cache for this space if it doesn't exist
684		if ( to && !this[ cache ] ) {
685			this[ cache ] = to( this._rgba );
686		}
687		if ( value === undefined ) {
688			return this[ cache ].slice();
689		}
690
691		var ret,
692			type = getType( value ),
693			arr = ( type === "array" || type === "object" ) ? value : arguments,
694			local = this[ cache ].slice();
695
696		each( props, function( key, prop ) {
697			var val = arr[ type === "object" ? key : prop.idx ];
698			if ( val == null ) {
699				val = local[ prop.idx ];
700			}
701			local[ prop.idx ] = clamp( val, prop );
702		} );
703
704		if ( from ) {
705			ret = color( from( local ) );
706			ret[ cache ] = local;
707			return ret;
708		} else {
709			return color( local );
710		}
711	};
712
713	// makes red() green() blue() alpha() hue() saturation() lightness()
714	each( props, function( key, prop ) {
715
716		// alpha is included in more than one space
717		if ( color.fn[ key ] ) {
718			return;
719		}
720		color.fn[ key ] = function( value ) {
721			var local, cur, match, fn,
722				vtype = getType( value );
723
724			if ( key === "alpha" ) {
725				fn = this._hsla ? "hsla" : "rgba";
726			} else {
727				fn = spaceName;
728			}
729			local = this[ fn ]();
730			cur = local[ prop.idx ];
731
732			if ( vtype === "undefined" ) {
733				return cur;
734			}
735
736			if ( vtype === "function" ) {
737				value = value.call( this, cur );
738				vtype = getType( value );
739			}
740			if ( value == null && prop.empty ) {
741				return this;
742			}
743			if ( vtype === "string" ) {
744				match = rplusequals.exec( value );
745				if ( match ) {
746					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
747				}
748			}
749			local[ prop.idx ] = value;
750			return this[ fn ]( local );
751		};
752	} );
753} );
754
755// add cssHook and .fx.step function for each named hook.
756// accept a space separated string of properties
757color.hook = function( hook ) {
758	var hooks = hook.split( " " );
759	each( hooks, function( _i, hook ) {
760		jQuery.cssHooks[ hook ] = {
761			set: function( elem, value ) {
762				var parsed;
763
764				if ( value !== "transparent" &&
765					( getType( value ) !== "string" ||
766						( parsed = stringParse( value ) ) ) ) {
767					value = color( parsed || value );
768					value = value.toRgbaString();
769				}
770				elem.style[ hook ] = value;
771			}
772		};
773		jQuery.fx.step[ hook ] = function( fx ) {
774			if ( !fx.colorInit ) {
775				fx.start = color( fx.elem, hook );
776				fx.end = color( fx.end );
777				fx.colorInit = true;
778			}
779			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
780		};
781	} );
782
783};
784
785color.hook( stepHooks );
786
787jQuery.cssHooks.borderColor = {
788	expand: function( value ) {
789		var expanded = {};
790
791		each( [ "Top", "Right", "Bottom", "Left" ], function( _i, part ) {
792			expanded[ "border" + part + "Color" ] = value;
793		} );
794		return expanded;
795	}
796};
797
798// Basic color names only.
799// Usage of any of the other color names requires adding yourself or including
800// jquery.color.svg-names.js.
801colors = jQuery.Color.names = {
802
803	// 4.1. Basic color keywords
804	aqua: "#00ffff",
805	black: "#000000",
806	blue: "#0000ff",
807	fuchsia: "#ff00ff",
808	gray: "#808080",
809	green: "#008000",
810	lime: "#00ff00",
811	maroon: "#800000",
812	navy: "#000080",
813	olive: "#808000",
814	purple: "#800080",
815	red: "#ff0000",
816	silver: "#c0c0c0",
817	teal: "#008080",
818	white: "#ffffff",
819	yellow: "#ffff00",
820
821	// 4.2.3. "transparent" color keyword
822	transparent: [ null, null, null, 0 ],
823
824	_default: "#ffffff"
825};
826

862
863
864var dataSpace = "ui-effects-",
865	dataSpaceStyle = "ui-effects-style",
866	dataSpaceAnimated = "ui-effects-animated";
867
868$.effects = {
869	effect: {}
870};
871
872/******************************************************************************/
873/****************************** CLASS ANIMATIONS ******************************/
874/******************************************************************************/
875( function() {
876
877var classAnimationActions = [ "add", "remove", "toggle" ],
878	shorthandStyles = {
879		border: 1,
880		borderBottom: 1,
881		borderColor: 1,
882		borderLeft: 1,
883		borderRight: 1,
884		borderTop: 1,
885		borderWidth: 1,
886		margin: 1,
887		padding: 1
888	};
889
890$.each(
891	[ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ],
892	function( _, prop ) {
893		$.fx.step[ prop ] = function( fx ) {
894			if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
895				jQuery.style( fx.elem, prop, fx.end );
896				fx.setAttr = true;
897			}
898		};
899	}
900);
901
902function camelCase( string ) {
903	return string.replace( /-([\da-z])/gi, function( all, letter ) {
904		return letter.toUpperCase();
905	} );
906}
907
908function getElementStyles( elem ) {
909	var key, len,
910		style = elem.ownerDocument.defaultView.getComputedStyle( elem ),
911		styles = {};
912
913	len = style.length;
914	while ( len-- ) {
915		key = style[ len ];
916		if ( typeof style[ key ] === "string" ) {
917			styles[ camelCase( key ) ] = style[ key ];
918		}
919	}
920
921	return styles;
922}
923
924function styleDifference( oldStyle, newStyle ) {
925	var diff = {},
926		name, value;
927
928	for ( name in newStyle ) {
929		value = newStyle[ name ];
930		if ( oldStyle[ name ] !== value ) {
931			if ( !shorthandStyles[ name ] ) {
932				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
933					diff[ name ] = value;
934				}
935			}
936		}
937	}
938
939	return diff;
940}
941
942$.effects.animateClass = function( value, duration, easing, callback ) {
943	var o = $.speed( duration, easing, callback );
944
945	return this.queue( function() {
946		var animated = $( this ),
947			baseClass = animated.attr( "class" ) || "",
948			applyClassChange,
949			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
950
951		// Map the animated objects to store the original styles.
952		allAnimations = allAnimations.map( function() {
953			var el = $( this );
954			return {
955				el: el,
956				start: getElementStyles( this )
957			};
958		} );
959
960		// Apply class change
961		applyClassChange = function() {
962			$.each( classAnimationActions, function( i, action ) {
963				if ( value[ action ] ) {
964					animated[ action + "Class" ]( value[ action ] );
965				}
966			} );
967		};
968		applyClassChange();
969
970		// Map all animated objects again - calculate new styles and diff
971		allAnimations = allAnimations.map( function() {
972			this.end = getElementStyles( this.el[ 0 ] );
973			this.diff = styleDifference( this.start, this.end );
974			return this;
975		} );
976
977		// Apply original class
978		animated.attr( "class", baseClass );
979
980		// Map all animated objects again - this time collecting a promise
981		allAnimations = allAnimations.map( function() {
982			var styleInfo = this,
983				dfd = $.Deferred(),
984				opts = $.extend( {}, o, {
985					queue: false,
986					complete: function() {
987						dfd.resolve( styleInfo );
988					}
989				} );
990
991			this.el.animate( this.diff, opts );
992			return dfd.promise();
993		} );
994
995		// Once all animations have completed:
996		$.when.apply( $, allAnimations.get() ).done( function() {
997
998			// Set the final class
999			applyClassChange();
1000
1001			// For each animated element,
1002			// clear all css properties that were animated
1003			$.each( arguments, function() {
1004				var el = this.el;
1005				$.each( this.diff, function( key ) {
1006					el.css( key, "" );
1007				} );
1008			} );
1009
1010			// This is guarnteed to be there if you use jQuery.speed()
1011			// it also handles dequeuing the next anim...
1012			o.complete.call( animated[ 0 ] );
1013		} );
1014	} );
1015};
1016
1017$.fn.extend( {
1018	addClass: ( function( orig ) {
1019		return function( classNames, speed, easing, callback ) {
1020			return speed ?
1021				$.effects.animateClass.call( this,
1022					{ add: classNames }, speed, easing, callback ) :
1023				orig.apply( this, arguments );
1024		};
1025	} )( $.fn.addClass ),
1026
1027	removeClass: ( function( orig ) {
1028		return function( classNames, speed, easing, callback ) {
1029			return arguments.length > 1 ?
1030				$.effects.animateClass.call( this,
1031					{ remove: classNames }, speed, easing, callback ) :
1032				orig.apply( this, arguments );
1033		};
1034	} )( $.fn.removeClass ),
1035
1036	toggleClass: ( function( orig ) {
1037		return function( classNames, force, speed, easing, callback ) {
1038			if ( typeof force === "boolean" || force === undefined ) {
1039				if ( !speed ) {
1040
1041					// Without speed parameter
1042					return orig.apply( this, arguments );
1043				} else {
1044					return $.effects.animateClass.call( this,
1045						( force ? { add: classNames } : { remove: classNames } ),
1046						speed, easing, callback );
1047				}
1048			} else {
1049
1050				// Without force parameter
1051				return $.effects.animateClass.call( this,
1052					{ toggle: classNames }, force, speed, easing );
1053			}
1054		};
1055	} )( $.fn.toggleClass ),
1056
1057	switchClass: function( remove, add, speed, easing, callback ) {
1058		return $.effects.animateClass.call( this, {
1059			add: add,
1060			remove: remove
1061		}, speed, easing, callback );
1062	}
1063} );
1064
1065} )();
1066
1067/******************************************************************************/
1068/*********************************** EFFECTS **********************************/
1069/******************************************************************************/
1070
1071( function() {
1072
1073if ( $.expr && $.expr.pseudos && $.expr.pseudos.animated ) {
1074	$.expr.pseudos.animated = ( function( orig ) {
1075		return function( elem ) {
1076			return !!$( elem ).data( dataSpaceAnimated ) || orig( elem );
1077		};
1078	} )( $.expr.pseudos.animated );
1079}
1080
1081if ( $.uiBackCompat === true ) {
1082	$.extend( $.effects, {
1083
1084		// Saves a set of properties in a data storage
1085		save: function( element, set ) {
1086			var i = 0, length = set.length;
1087			for ( ; i < length; i++ ) {
1088				if ( set[ i ] !== null ) {
1089					element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
1090				}
1091			}
1092		},
1093
1094		// Restores a set of previously saved properties from a data storage
1095		restore: function( element, set ) {
1096			var val, i = 0, length = set.length;
1097			for ( ; i < length; i++ ) {
1098				if ( set[ i ] !== null ) {
1099					val = element.data( dataSpace + set[ i ] );
1100					element.css( set[ i ], val );
1101				}
1102			}
1103		},
1104
1105		setMode: function( el, mode ) {
1106			if ( mode === "toggle" ) {
1107				mode = el.is( ":hidden" ) ? "show" : "hide";
1108			}
1109			return mode;
1110		},
1111
1112		// Wraps the element around a wrapper that copies position properties
1113		createWrapper: function( element ) {
1114
1115			// If the element is already wrapped, return it
1116			if ( element.parent().is( ".ui-effects-wrapper" ) ) {
1117				return element.parent();
1118			}
1119
1120			// Wrap the element
1121			var props = {
1122					width: element.outerWidth( true ),
1123					height: element.outerHeight( true ),
1124					"float": element.css( "float" )
1125				},
1126				wrapper = $( "<div></div>" )
1127					.addClass( "ui-effects-wrapper" )
1128					.css( {
1129						fontSize: "100%",
1130						background: "transparent",
1131						border: "none",
1132						margin: 0,
1133						padding: 0
1134					} ),
1135
1136				// Store the size in case width/height are defined in % - Fixes #5245
1137				size = {
1138					width: element.width(),
1139					height: element.height()
1140				},
1141				active = document.activeElement;
1142
1143			// Support: Firefox
1144			// Firefox incorrectly exposes anonymous content
1145			// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
1146			try {
1147				// eslint-disable-next-line no-unused-expressions
1148				active.id;
1149			} catch ( _e ) {
1150				active = document.body;
1151			}
1152
1153			element.wrap( wrapper );
1154
1155			// Fixes #7595 - Elements lose focus when wrapped.
1156			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
1157				$( active ).trigger( "focus" );
1158			}
1159
1160			// Hotfix for jQuery 1.4 since some change in wrap() seems to actually
1161			// lose the reference to the wrapped element
1162			wrapper = element.parent();
1163
1164			// Transfer positioning properties to the wrapper
1165			if ( element.css( "position" ) === "static" ) {
1166				wrapper.css( { position: "relative" } );
1167				element.css( { position: "relative" } );
1168			} else {
1169				$.extend( props, {
1170					position: element.css( "position" ),
1171					zIndex: element.css( "z-index" )
1172				} );
1173				$.each( [ "top", "left", "bottom", "right" ], function( i, pos ) {
1174					props[ pos ] = element.css( pos );
1175					if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
1176						props[ pos ] = "auto";
1177					}
1178				} );
1179				element.css( {
1180					position: "relative",
1181					top: 0,
1182					left: 0,
1183					right: "auto",
1184					bottom: "auto"
1185				} );
1186			}
1187			element.css( size );
1188
1189			return wrapper.css( props ).show();
1190		},
1191
1192		removeWrapper: function( element ) {
1193			var active = document.activeElement;
1194
1195			if ( element.parent().is( ".ui-effects-wrapper" ) ) {
1196				element.parent().replaceWith( element );
1197
1198				// Fixes #7595 - Elements lose focus when wrapped.
1199				if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
1200					$( active ).trigger( "focus" );
1201				}
1202			}
1203
1204			return element;
1205		}
1206	} );
1207}
1208
1209$.extend( $.effects, {
1210	version: "

1210",
1211
1212	define: function( name, mode, effect ) {
1213		if ( !effect ) {
1214			effect = mode;
1215			mode = "effect";
1216		}
1217
1218		$.effects.effect[ name ] = effect;
1219		$.effects.effect[ name ].mode = mode;
1220
1221		return effect;
1222	},
1223
1224	scaledDimensions: function( element, percent, direction ) {
1225		if ( percent === 0 ) {
1226			return {
1227				height: 0,
1228				width: 0,
1229				outerHeight: 0,
1230				outerWidth: 0
1231			};
1232		}
1233
1234		var x = direction !== "horizontal" ? ( ( percent || 100 ) / 100 ) : 1,
1235			y = direction !== "vertical" ? ( ( percent || 100 ) / 100 ) : 1;
1236
1237		return {
1238			height: element.height() * y,
1239			width: element.width() * x,
1240			outerHeight: element.outerHeight() * y,
1241			outerWidth: element.outerWidth() * x
1242		};
1243
1244	},
1245
1246	clipToBox: function( animation ) {
1247		return {
1248			width: animation.clip.right - animation.clip.left,
1249			height: animation.clip.bottom - animation.clip.top,
1250			left: animation.clip.left,
1251			top: animation.clip.top
1252		};
1253	},
1254
1255	// Injects recently queued functions to be first in line (after "inprogress")
1256	unshift: function( element, queueLength, count ) {
1257		var queue = element.queue();
1258
1259		if ( queueLength > 1 ) {
1260			queue.splice.apply( queue,
1261				[ 1, 0 ].concat( queue.splice( queueLength, count ) ) );
1262		}
1263		element.dequeue();
1264	},
1265
1266	saveStyle: function( element ) {
1267		element.data( dataSpaceStyle, element[ 0 ].style.cssText );
1268	},
1269
1270	restoreStyle: function( element ) {
1271		element[ 0 ].style.cssText = element.data( dataSpaceStyle ) || "";
1272		element.removeData( dataSpaceStyle );
1273	},
1274
1275	mode: function( element, mode ) {
1276		var hidden = element.is( ":hidden" );
1277
1278		if ( mode === "toggle" ) {
1279			mode = hidden ? "show" : "hide";
1280		}
1281		if ( hidden ? mode === "hide" : mode === "show" ) {
1282			mode = "none";
1283		}
1284		return mode;
1285	},
1286
1287	// Translates a [top,left] array into a baseline value
1288	getBaseline: function( origin, original ) {
1289		var y, x;
1290
1291		switch ( origin[ 0 ] ) {
1292		case "top":
1293			y = 0;
1294			break;
1295		case "middle":
1296			y = 0.5;
1297			break;
1298		case "bottom":
1299			y = 1;
1300			break;
1301		default:
1302			y = origin[ 0 ] / original.height;
1303		}
1304
1305		switch ( origin[ 1 ] ) {
1306		case "left":
1307			x = 0;
1308			break;
1309		case "center":
1310			x = 0.5;
1311			break;
1312		case "right":
1313			x = 1;
1314			break;
1315		default:
1316			x = origin[ 1 ] / original.width;
1317		}
1318
1319		return {
1320			x: x,
1321			y: y
1322		};
1323	},
1324
1325	// Creates a placeholder element so that the original element can be made absolute
1326	createPlaceholder: function( element ) {
1327		var placeholder,
1328			cssPosition = element.css( "position" ),
1329			position = element.position();
1330
1331		// Lock in margins first to account for form elements, which
1332		// will change margin if you explicitly set height
1333		// see: https://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380
1334		// Support: Safari
1335		element.css( {
1336			marginTop: element.css( "marginTop" ),
1337			marginBottom: element.css( "marginBottom" ),
1338			marginLeft: element.css( "marginLeft" ),
1339			marginRight: element.css( "marginRight" )
1340		} )
1341		.outerWidth( element.outerWidth() )
1342		.outerHeight( element.outerHeight() );
1343
1344		if ( /^(static|relative)/.test( cssPosition ) ) {
1345			cssPosition = "absolute";
1346
1347			placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( {
1348
1349				// Convert inline to inline block to account for inline elements
1350				// that turn to inline block based on content (like img)
1351				display: /^(inline|ruby)/.test( element.css( "display" ) ) ?
1352					"inline-block" :
1353					"block",
1354				visibility: "hidden",
1355
1356				// Margins need to be set to account for margin collapse
1357				marginTop: element.css( "marginTop" ),
1358				marginBottom: element.css( "marginBottom" ),
1359				marginLeft: element.css( "marginLeft" ),
1360				marginRight: element.css( "marginRight" ),
1361				"float": element.css( "float" )
1362			} )
1363			.outerWidth( element.outerWidth() )
1364			.outerHeight( element.outerHeight() )
1365			.addClass( "ui-effects-placeholder" );
1366
1367			element.data( dataSpace + "placeholder", placeholder );
1368		}
1369
1370		element.css( {
1371			position: cssPosition,
1372			left: position.left,
1373			top: position.top
1374		} );
1375
1376		return placeholder;
1377	},
1378
1379	removePlaceholder: function( element ) {
1380		var dataKey = dataSpace + "placeholder",
1381				placeholder = element.data( dataKey );
1382
1383		if ( placeholder ) {
1384			placeholder.remove();
1385			element.removeData( dataKey );
1386		}
1387	},
1388
1389	// Removes a placeholder if it exists and restores
1390	// properties that were modified during placeholder creation
1391	cleanUp: function( element ) {
1392		$.effects.restoreStyle( element );
1393		$.effects.removePlaceholder( element );
1394	},
1395
1396	setTransition: function( element, list, factor, value ) {
1397		value = value || {};
1398		$.each( list, function( i, x ) {
1399			var unit = element.cssUnit( x );
1400			if ( unit[ 0 ] > 0 ) {
1401				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
1402			}
1403		} );
1404		return value;
1405	}
1406} );
1407
1408// Return an effect options object for the given parameters:
1409function _normalizeArguments( effect, options, speed, callback ) {
1410
1411	// Allow passing all options as the first parameter
1412	if ( $.isPlainObject( effect ) ) {
1413		options = effect;
1414		effect = effect.effect;
1415	}
1416
1417	// Convert to an object
1418	effect = { effect: effect };
1419
1420	// Catch (effect, null, ...)
1421	if ( options == null ) {
1422		options = {};
1423	}
1424
1425	// Catch (effect, callback)
1426	if ( typeof options === "function" ) {
1427		callback = options;
1428		speed = null;
1429		options = {};
1430	}
1431
1432	// Catch (effect, speed, ?)
1433	if ( typeof options === "number" || $.fx.speeds[ options ] ) {
1434		callback = speed;
1435		speed = options;
1436		options = {};
1437	}
1438
1439	// Catch (effect, options, callback)
1440	if ( typeof speed === "function" ) {
1441		callback = speed;
1442		speed = null;
1443	}
1444
1445	// Add options to effect
1446	if ( options ) {
1447		$.extend( effect, options );
1448	}
1449
1450	speed = speed || options.duration;
1451	effect.duration = $.fx.off ? 0 :
1452		typeof speed === "number" ? speed :
1453		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
1454		$.fx.speeds._default;
1455
1456	effect.complete = callback || options.complete;
1457
1458	return effect;
1459}
1460
1461function standardAnimationOption( option ) {
1462
1463	// Valid standard speeds (nothing, number, named speed)
1464	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
1465		return true;
1466	}
1467
1468	// Invalid strings - treat as "normal" speed
1469	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
1470		return true;
1471	}
1472
1473	// Complete callback
1474	if ( typeof option === "function" ) {
1475		return true;
1476	}
1477
1478	// Options hash (but not naming an effect)
1479	if ( typeof option === "object" && !option.effect ) {
1480		return true;
1481	}
1482
1483	// Didn't match any standard API
1484	return false;
1485}
1486
1487$.fn.extend( {
1488	effect: function( /* effect, options, speed, callback */ ) {
1489		var args = _normalizeArguments.apply( this, arguments ),
1490			effectMethod = $.effects.effect[ args.effect ],
1491			defaultMode = effectMethod.mode,
1492			queue = args.queue,
1493			queueName = queue || "fx",
1494			complete = args.complete,
1495			mode = args.mode,
1496			modes = [],
1497			prefilter = function( next ) {
1498				var el = $( this ),
1499					normalizedMode = $.effects.mode( el, mode ) || defaultMode;
1500
1501				// Sentinel for duck-punching the :animated pseudo-selector
1502				el.data( dataSpaceAnimated, true );
1503
1504				// Save effect mode for later use,
1505				// we can't just call $.effects.mode again later,
1506				// as the .show() below destroys the initial state
1507				modes.push( normalizedMode );
1508
1509				// See $.uiBackCompat inside of run() for removal of defaultMode in 1.14
1510				if ( defaultMode && ( normalizedMode === "show" ||
1511						( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) {
1512					el.show();
1513				}
1514
1515				if ( !defaultMode || normalizedMode !== "none" ) {
1516					$.effects.saveStyle( el );
1517				}
1518
1519				if ( typeof next === "function" ) {
1520					next();
1521				}
1522			};
1523
1524		if ( $.fx.off || !effectMethod ) {
1525
1526			// Delegate to the original method (e.g., .show()) if possible
1527			if ( mode ) {
1528				return this[ mode ]( args.duration, complete );
1529			} else {
1530				return this.each( function() {
1531					if ( complete ) {
1532						complete.call( this );
1533					}
1534				} );
1535			}
1536		}
1537
1538		function run( next ) {
1539			var elem = $( this );
1540
1541			function cleanup() {
1542				elem.removeData( dataSpaceAnimated );
1543
1544				$.effects.cleanUp( elem );
1545
1546				if ( args.mode === "hide" ) {
1547					elem.hide();
1548				}
1549
1550				done();
1551			}
1552
1553			function done() {
1554				if ( typeof complete === "function" ) {
1555					complete.call( elem[ 0 ] );
1556				}
1557
1558				if ( typeof next === "function" ) {
1559					next();
1560				}
1561			}
1562
1563			// Override mode option on a per element basis,
1564			// as toggle can be either show or hide depending on element state
1565			args.mode = modes.shift();
1566
1567			if ( $.uiBackCompat === true && !defaultMode ) {
1568				if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
1569
1570					// Call the core method to track "olddisplay" properly
1571					elem[ mode ]();
1572					done();
1573				} else {
1574					effectMethod.call( elem[ 0 ], args, done );
1575				}
1576			} else {
1577				if ( args.mode === "none" ) {
1578
1579					// Call the core method to track "olddisplay" properly
1580					elem[ mode ]();
1581					done();
1582				} else {
1583					effectMethod.call( elem[ 0 ], args, cleanup );
1584				}
1585			}
1586		}
1587
1588		// Run prefilter on all elements first to ensure that
1589		// any showing or hiding happens before placeholder creation,
1590		// which ensures that any layout changes are correctly captured.
1591		return queue === false ?
1592			this.each( prefilter ).each( run ) :
1593			this.queue( queueName, prefilter ).queue( queueName, run );
1594	},
1595
1596	show: ( function( orig ) {
1597		return function( option ) {
1598			if ( standardAnimationOption( option ) ) {
1599				return orig.apply( this, arguments );
1600			} else {
1601				var args = _normalizeArguments.apply( this, arguments );
1602				args.mode = "show";
1603				return this.effect.call( this, args );
1604			}
1605		};
1606	} )( $.fn.show ),
1607
1608	hide: ( function( orig ) {
1609		return function( option ) {
1610			if ( standardAnimationOption( option ) ) {
1611				return orig.apply( this, arguments );
1612			} else {
1613				var args = _normalizeArguments.apply( this, arguments );
1614				args.mode = "hide";
1615				return this.effect.call( this, args );
1616			}
1617		};
1618	} )( $.fn.hide ),
1619
1620	toggle: ( function( orig ) {
1621		return function( option ) {
1622			if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
1623				return orig.apply( this, arguments );
1624			} else {
1625				var args = _normalizeArguments.apply( this, arguments );
1626				args.mode = "toggle";
1627				return this.effect.call( this, args );
1628			}
1629		};
1630	} )( $.fn.toggle ),
1631
1632	cssUnit: function( key ) {
1633		var style = this.css( key ),
1634			val = [];
1635
1636		$.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
1637			if ( style.indexOf( unit ) > 0 ) {
1638				val = [ parseFloat( style ), unit ];
1639			}
1640		} );
1641		return val;
1642	},
1643
1644	cssClip: function( clipObj ) {
1645		if ( clipObj ) {
1646			return this.css( "clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " +
1647				clipObj.bottom + "px " + clipObj.left + "px)" );
1648		}
1649		return parseClip( this.css( "clip" ), this );
1650	},
1651
1652	transfer: function( options, done ) {
1653		var element = $( this ),
1654			target = $( options.to ),
1655			targetFixed = target.css( "position" ) === "fixed",
1656			body = $( "body" ),
1657			fixTop = targetFixed ? body.scrollTop() : 0,
1658			fixLeft = targetFixed ? body.scrollLeft() : 0,
1659			endPosition = target.offset(),
1660			animation = {
1661				top: endPosition.top - fixTop,
1662				left: endPosition.left - fixLeft,
1663				height: target.innerHeight(),
1664				width: target.innerWidth()
1665			},
1666			startPosition = element.offset(),
1667			transfer = $( "<div class='ui-effects-transfer'></div>" );
1668
1669		transfer
1670			.appendTo( "body" )
1671			.addClass( options.className )
1672			.css( {
1673				top: startPosition.top - fixTop,
1674				left: startPosition.left - fixLeft,
1675				height: element.innerHeight(),
1676				width: element.innerWidth(),
1677				position: targetFixed ? "fixed" : "absolute"
1678			} )
1679			.animate( animation, options.duration, options.easing, function() {
1680				transfer.remove();
1681				if ( typeof done === "function" ) {
1682					done();
1683				}
1684			} );
1685	}
1686} );
1687
1688function parseClip( str, element ) {
1689		var outerWidth = element.outerWidth(),
1690			outerHeight = element.outerHeight(),
1691			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)\)$/,
1692			values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ];
1693
1694		return {
1695			top: parseFloat( values[ 1 ] ) || 0,
1696			right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ),
1697			bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ),
1698			left: parseFloat( values[ 4 ] ) || 0
1699		};
1700}
1701
1702$.fx.step.clip = function( fx ) {
1703	if ( !fx.clipInit ) {
1704		fx.start = $( fx.elem ).cssClip();
1705		if ( typeof fx.end === "string" ) {
1706			fx.end = parseClip( fx.end, fx.elem );
1707		}
1708		fx.clipInit = true;
1709	}
1710
1711	$( fx.elem ).cssClip( {
1712		top: fx.pos * ( fx.end.top - fx.start.top ) + fx.start.top,
1713		right: fx.pos * ( fx.end.right - fx.start.right ) + fx.start.right,
1714		bottom: fx.pos * ( fx.end.bottom - fx.start.bottom ) + fx.start.bottom,
1715		left: fx.pos * ( fx.end.left - fx.start.left ) + fx.start.left
1716	} );
1717};
1718
1719} )();
1720
1721/******************************************************************************/
1722/*********************************** EASING ***********************************/
1723/******************************************************************************/
1724
1725( function() {
1726
1727// Based on easing equations from Robert Penner (http://robertpenner.com/easing)
1728
1729var baseEasings = {};
1730
1731$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
1732	baseEasings[ name ] = function( p ) {
1733		return Math.pow( p, i + 2 );
1734	};
1735} );
1736
1737$.extend( baseEasings, {
1738	Sine: function( p ) {
1739		return 1 - Math.cos( p * Math.PI / 2 );
1740	},
1741	Circ: function( p ) {
1742		return 1 - Math.sqrt( 1 - p * p );
1743	},
1744	Elastic: function( p ) {
1745		return p === 0 || p === 1 ? p :
1746			-Math.pow( 2, 8 * ( p - 1 ) ) * Math.sin( ( ( p - 1 ) * 80 - 7.5 ) * Math.PI / 15 );
1747	},
1748	Back: function( p ) {
1749		return p * p * ( 3 * p - 2 );
1750	},
1751	Bounce: function( p ) {
1752		var pow2,
1753			bounce = 4;
1754
1755		while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
1756		return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
1757	}
1758} );
1759
1760$.each( baseEasings, function( name, easeIn ) {
1761	$.easing[ "easeIn" + name ] = easeIn;
1762	$.easing[ "easeOut" + name ] = function( p ) {
1763		return 1 - easeIn( 1 - p );
1764	};
1765	$.easing[ "easeInOut" + name ] = function( p ) {
1766		return p < 0.5 ?
1767			easeIn( p * 2 ) / 2 :
1768			1 - easeIn( p * -2 + 2 ) / 2;
1769	};
1770} );
1771
1772} )();
1773

1774return $.effects;
1775
1776} );
1777
1778/*!
1779 * jQuery UI Effects Blind @VERSION
1780 * https://jqueryui.com
1781 *
1782 * Copyright OpenJS Foundation and other contributors
1783 * Released under the MIT license.
1784 * https://jquery.org/license
1785 */
1786
1787//>>label: Blind Effect
1788//>>group: Effects
1789//>>description: Blinds the element.
1790//>>docs: https://api.jqueryui.com/blind-effect/
1791//>>demos: https://jqueryui.com/effect/
1792
1793( function( factory ) {
1794	"use strict";
1795
1796	if ( typeof define === "function" && define.amd ) {
1797
1798		// AMD. Register as an anonymous module.
1799		define( 'ui/effects/effect-blind.js',[
1800			"jquery",
1801			"../version",
1802			"../effect"
1803		], factory );
1804	} else {
1805
1806		// Browser globals
1807		factory( jQuery );
1808	}
1809} )( function( $ ) {
1810"use strict";
1811
1812return $.effects.define( "blind", "hide", function( options, done ) {
1813	var map = {
1814			up: [ "bottom", "top" ],
1815			vertical: [ "bottom", "top" ],
1816			down: [ "top", "bottom" ],
1817			left: [ "right", "left" ],
1818			horizontal: [ "right", "left" ],
1819			right: [ "left", "right" ]
1820		},
1821		element = $( this ),
1822		direction = options.direction || "up",
1823		start = element.cssClip(),
1824		animate = { clip: $.extend( {}, start ) },
1825		placeholder = $.effects.createPlaceholder( element );
1826
1827	animate.clip[ map[ direction ][ 0 ] ] = animate.clip[ map[ direction ][ 1 ] ];
1828
1829	if ( options.mode === "show" ) {
1830		element.cssClip( animate.clip );
1831		if ( placeholder ) {
1832			placeholder.css( $.effects.clipToBox( animate ) );
1833		}
1834
1835		animate.clip = start;
1836	}
1837
1838	if ( placeholder ) {
1839		placeholder.animate( $.effects.clipToBox( animate ), options.duration, options.easing );
1840	}
1841
1842	element.animate( animate, {
1843		queue: false,
1844		duration: options.duration,
1845		easing: options.easing,
1846		complete: done
1847	} );
1848} );
1849
1850} );
1851
1852/*!
1853 * jQuery UI Effects Bounce @VERSION
1854 * https://jqueryui.com
1855 *
1856 * Copyright OpenJS Foundation and other contributors
1857 * Released under the MIT license.
1858 * https://jquery.org/license
1859 */
1860
1861//>>label: Bounce Effect
1862//>>group: Effects
1863//>>description: Bounces an element horizontally or vertically n times.
1864//>>docs: https://api.jqueryui.com/bounce-effect/
1865//>>demos: https://jqueryui.com/effect/
1866
1867( function( factory ) {
1868	"use strict";
1869
1870	if ( typeof define === "function" && define.amd ) {
1871
1872		// AMD. Register as an anonymous module.
1873		define( 'ui/effects/effect-bounce.js',[
1874			"jquery",
1875			"../version",
1876			"../effect"
1877		], factory );
1878	} else {
1879
1880		// Browser globals
1881		factory( jQuery );
1882	}
1883} )( function( $ ) {
1884"use strict";
1885
1886return $.effects.define( "bounce", function( options, done ) {
1887	var upAnim, downAnim, refValue,
1888		element = $( this ),
1889
1890		// Defaults:
1891		mode = options.mode,
1892		hide = mode === "hide",
1893		show = mode === "show",
1894		direction = options.direction || "up",
1895		distance = options.distance,
1896		times = options.times || 5,
1897
1898		// Number of internal animations
1899		anims = times * 2 + ( show || hide ? 1 : 0 ),
1900		speed = options.duration / anims,
1901		easing = options.easing,
1902
1903		// Utility:
1904		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
1905		motion = ( direction === "up" || direction === "left" ),
1906		i = 0,
1907
1908		queuelen = element.queue().length;
1909
1910	$.effects.createPlaceholder( element );
1911
1912	refValue = element.css( ref );
1913
1914	// Default distance for the BIGGEST bounce is the outer Distance / 3
1915	if ( !distance ) {
1916		distance = element[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
1917	}
1918
1919	if ( show ) {
1920		downAnim = { opacity: 1 };
1921		downAnim[ ref ] = refValue;
1922
1923		// If we are showing, force opacity 0 and set the initial position
1924		// then do the "first" animation
1925		element
1926			.css( "opacity", 0 )
1927			.css( ref, motion ? -distance * 2 : distance * 2 )
1928			.animate( downAnim, speed, easing );
1929	}
1930
1931	// Start at the smallest distance if we are hiding
1932	if ( hide ) {
1933		distance = distance / Math.pow( 2, times - 1 );
1934	}
1935
1936	downAnim = {};
1937	downAnim[ ref ] = refValue;
1938
1939	// Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
1940	for ( ; i < times; i++ ) {
1941		upAnim = {};
1942		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
1943
1944		element
1945			.animate( upAnim, speed, easing )
1946			.animate( downAnim, speed, easing );
1947
1948		distance = hide ? distance * 2 : distance / 2;
1949	}
1950
1951	// Last Bounce when Hiding
1952	if ( hide ) {
1953		upAnim = { opacity: 0 };
1954		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
1955
1956		element.animate( upAnim, speed, easing );
1957	}
1958
1959	element.queue( done );
1960
1961	$.effects.unshift( element, queuelen, anims + 1 );
1962} );
1963
1964} );
1965
1966/*!
1967 * jQuery UI Effects Clip @VERSION
1968 * https://jqueryui.com
1969 *
1970 * Copyright OpenJS Foundation and other contributors
1971 * Released under the MIT license.
1972 * https://jquery.org/license
1973 */
1974
1975//>>label: Clip Effect
1976//>>group: Effects
1977//>>description: Clips the element on and off like an old TV.
1978//>>docs: https://api.jqueryui.com/clip-effect/
1979//>>demos: https://jqueryui.com/effect/
1980
1981( function( factory ) {
1982	"use strict";
1983
1984	if ( typeof define === "function" && define.amd ) {
1985
1986		// AMD. Register as an anonymous module.
1987		define( 'ui/effects/effect-clip.js',[
1988			"jquery",
1989			"../version",
1990			"../effect"
1991		], factory );
1992	} else {
1993
1994		// Browser globals
1995		factory( jQuery );
1996	}
1997} )( function( $ ) {
1998"use strict";
1999
2000return $.effects.define( "clip", "hide", function( options, done ) {
2001	var start,
2002		animate = {},
2003		element = $( this ),
2004		direction = options.direction || "vertical",
2005		both = direction === "both",
2006		horizontal = both || direction === "horizontal",
2007		vertical = both || direction === "vertical";
2008
2009	start = element.cssClip();
2010	animate.clip = {
2011		top: vertical ? ( start.bottom - start.top ) / 2 : start.top,
2012		right: horizontal ? ( start.right - start.left ) / 2 : start.right,
2013		bottom: vertical ? ( start.bottom - start.top ) / 2 : start.bottom,
2014		left: horizontal ? ( start.right - start.left ) / 2 : start.left
2015	};
2016
2017	$.effects.createPlaceholder( element );
2018
2019	if ( options.mode === "show" ) {
2020		element.cssClip( animate.clip );
2021		animate.clip = start;
2022	}
2023
2024	element.animate( animate, {
2025		queue: false,
2026		duration: options.duration,
2027		easing: options.easing,
2028		complete: done
2029	} );
2030
2031} );
2032
2033} );
2034
2035/*!
2036 * jQuery UI Effects Drop @VERSION
2037 * https://jqueryui.com
2038 *
2039 * Copyright OpenJS Foundation and other contributors
2040 * Released under the MIT license.
2041 * https://jquery.org/license
2042 */
2043
2044//>>label: Drop Effect
2045//>>group: Effects
2046//>>description: Moves an element in one direction and hides it at the same time.
2047//>>docs: https://api.jqueryui.com/drop-effect/
2048//>>demos: https://jqueryui.com/effect/
2049
2050( function( factory ) {
2051	"use strict";
2052
2053	if ( typeof define === "function" && define.amd ) {
2054
2055		// AMD. Register as an anonymous module.
2056		define( 'ui/effects/effect-drop.js',[
2057			"jquery",
2058			"../version",
2059			"../effect"
2060		], factory );
2061	} else {
2062
2063		// Browser globals
2064		factory( jQuery );
2065	}
2066} )( function( $ ) {
2067"use strict";
2068
2069return $.effects.define( "drop", "hide", function( options, done ) {
2070
2071	var distance,
2072		element = $( this ),
2073		mode = options.mode,
2074		show = mode === "show",
2075		direction = options.direction || "left",
2076		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
2077		motion = ( direction === "up" || direction === "left" ) ? "-=" : "+=",
2078		oppositeMotion = ( motion === "+=" ) ? "-=" : "+=",
2079		animation = {
2080			opacity: 0
2081		};
2082
2083	$.effects.createPlaceholder( element );
2084
2085	distance = options.distance ||
2086		element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
2087
2088	animation[ ref ] = motion + distance;
2089
2090	if ( show ) {
2091		element.css( animation );
2092
2093		animation[ ref ] = oppositeMotion + distance;
2094		animation.opacity = 1;
2095	}
2096
2097	// Animate
2098	element.animate( animation, {
2099		queue: false,
2100		duration: options.duration,
2101		easing: options.easing,
2102		complete: done
2103	} );
2104} );
2105
2106} );
2107
2108/*!
2109 * jQuery UI Effects Explode @VERSION
2110 * https://jqueryui.com
2111 *
2112 * Copyright OpenJS Foundation and other contributors
2113 * Released under the MIT license.
2114 * https://jquery.org/license
2115 */
2116
2117//>>label: Explode Effect
2118//>>group: Effects
2119//>>description: Explodes an element in all directions into n pieces. Implodes an element to its original wholeness.
2120//>>docs: https://api.jqueryui.com/explode-effect/
2121//>>demos: https://jqueryui.com/effect/
2122
2123( function( factory ) {
2124	"use strict";
2125
2126	if ( typeof define === "function" && define.amd ) {
2127
2128		// AMD. Register as an anonymous module.
2129		define( 'ui/effects/effect-explode.js',[
2130			"jquery",
2131			"../version",
2132			"../effect"
2133		], factory );
2134	} else {
2135
2136		// Browser globals
2137		factory( jQuery );
2138	}
2139} )( function( $ ) {
2140"use strict";
2141
2142return $.effects.define( "explode", "hide", function( options, done ) {
2143
2144	var i, j, left, top, mx, my,
2145		rows = options.pieces ? Math.round( Math.sqrt( options.pieces ) ) : 3,
2146		cells = rows,
2147		element = $( this ),
2148		mode = options.mode,
2149		show = mode === "show",
2150
2151		// Show and then visibility:hidden the element before calculating offset
2152		offset = element.show().css( "visibility", "hidden" ).offset(),
2153
2154		// Width and height of a piece
2155		width = Math.ceil( element.outerWidth() / cells ),
2156		height = Math.ceil( element.outerHeight() / rows ),
2157		pieces = [];
2158
2159	// Children animate complete:
2160	function childComplete() {
2161		pieces.push( this );
2162		if ( pieces.length === rows * cells ) {
2163			animComplete();
2164		}
2165	}
2166
2167	// Clone the element for each row and cell.
2168	for ( i = 0; i < rows; i++ ) { // ===>
2169		top = offset.top + i * height;
2170		my = i - ( rows - 1 ) / 2;
2171
2172		for ( j = 0; j < cells; j++ ) { // |||
2173			left = offset.left + j * width;
2174			mx = j - ( cells - 1 ) / 2;
2175
2176			// Create a clone of the now hidden main element that will be absolute positioned
2177			// within a wrapper div off the -left and -top equal to size of our pieces
2178			element
2179				.clone()
2180				.appendTo( "body" )
2181				.wrap( "<div></div>" )
2182				.css( {
2183					position: "absolute",
2184					visibility: "visible",
2185					left: -j * width,
2186					top: -i * height
2187				} )
2188
2189				// Select the wrapper - make it overflow: hidden and absolute positioned based on
2190				// where the original was located +left and +top equal to the size of pieces
2191				.parent()
2192					.addClass( "ui-effects-explode" )
2193					.css( {
2194						position: "absolute",
2195						overflow: "hidden",
2196						width: width,
2197						height: height,
2198						left: left + ( show ? mx * width : 0 ),
2199						top: top + ( show ? my * height : 0 ),
2200						opacity: show ? 0 : 1
2201					} )
2202					.animate( {
2203						left: left + ( show ? 0 : mx * width ),
2204						top: top + ( show ? 0 : my * height ),
2205						opacity: show ? 1 : 0
2206					}, options.duration || 500, options.easing, childComplete );
2207		}
2208	}
2209
2210	function animComplete() {
2211		element.css( {
2212			visibility: "visible"
2213		} );
2214		$( pieces ).remove();
2215		done();
2216	}
2217} );
2218
2219} );
2220
2221/*!
2222 * jQuery UI Effects Fade @VERSION
2223 * https://jqueryui.com
2224 *
2225 * Copyright OpenJS Foundation and other contributors
2226 * Released under the MIT license.
2227 * https://jquery.org/license
2228 */
2229
2230//>>label: Fade Effect
2231//>>group: Effects
2232//>>description: Fades the element.
2233//>>docs: https://api.jqueryui.com/fade-effect/
2234//>>demos: https://jqueryui.com/effect/
2235
2236( function( factory ) {
2237	"use strict";
2238
2239	if ( typeof define === "function" && define.amd ) {
2240
2241		// AMD. Register as an anonymous module.
2242		define( 'ui/effects/effect-fade.js',[
2243			"jquery",
2244			"../version",
2245			"../effect"
2246		], factory );
2247	} else {
2248
2249		// Browser globals
2250		factory( jQuery );
2251	}
2252} )( function( $ ) {
2253"use strict";
2254
2255return $.effects.define( "fade", "toggle", function( options, done ) {
2256	var show = options.mode === "show";
2257
2258	$( this )
2259		.css( "opacity", show ? 0 : 1 )
2260		.animate( {
2261			opacity: show ? 1 : 0
2262		}, {
2263			queue: false,
2264			duration: options.duration,
2265			easing: options.easing,
2266			complete: done
2267		} );
2268} );
2269
2270} );
2271
2272/*!
2273 * jQuery UI Effects Fold @VERSION
2274 * https://jqueryui.com
2275 *
2276 * Copyright OpenJS Foundation and other contributors
2277 * Released under the MIT license.
2278 * https://jquery.org/license
2279 */
2280
2281//>>label: Fold Effect
2282//>>group: Effects
2283//>>description: Folds an element first horizontally and then vertically.
2284//>>docs: https://api.jqueryui.com/fold-effect/
2285//>>demos: https://jqueryui.com/effect/
2286
2287( function( factory ) {
2288	"use strict";
2289
2290	if ( typeof define === "function" && define.amd ) {
2291
2292		// AMD. Register as an anonymous module.
2293		define( 'ui/effects/effect-fold.js',[
2294			"jquery",
2295			"../version",
2296			"../effect"
2297		], factory );
2298	} else {
2299
2300		// Browser globals
2301		factory( jQuery );
2302	}
2303} )( function( $ ) {
2304"use strict";
2305
2306return $.effects.define( "fold", "hide", function( options, done ) {
2307
2308	// Create element
2309	var element = $( this ),
2310		mode = options.mode,
2311		show = mode === "show",
2312		hide = mode === "hide",
2313		size = options.size || 15,
2314		percent = /([0-9]+)%/.exec( size ),
2315		horizFirst = !!options.horizFirst,
2316		ref = horizFirst ? [ "right", "bottom" ] : [ "bottom", "right" ],
2317		duration = options.duration / 2,
2318
2319		placeholder = $.effects.createPlaceholder( element ),
2320
2321		start = element.cssClip(),
2322		animation1 = { clip: $.extend( {}, start ) },
2323		animation2 = { clip: $.extend( {}, start ) },
2324
2325		distance = [ start[ ref[ 0 ] ], start[ ref[ 1 ] ] ],
2326
2327		queuelen = element.queue().length;
2328
2329	if ( percent ) {
2330		size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
2331	}
2332	animation1.clip[ ref[ 0 ] ] = size;
2333	animation2.clip[ ref[ 0 ] ] = size;
2334	animation2.clip[ ref[ 1 ] ] = 0;
2335
2336	if ( show ) {
2337		element.cssClip( animation2.clip );
2338		if ( placeholder ) {
2339			placeholder.css( $.effects.clipToBox( animation2 ) );
2340		}
2341
2342		animation2.clip = start;
2343	}
2344
2345	// Animate
2346	element
2347		.queue( function( next ) {
2348			if ( placeholder ) {
2349				placeholder
2350					.animate( $.effects.clipToBox( animation1 ), duration, options.easing )
2351					.animate( $.effects.clipToBox( animation2 ), duration, options.easing );
2352			}
2353
2354			next();
2355		} )
2356		.animate( animation1, duration, options.easing )
2357		.animate( animation2, duration, options.easing )
2358		.queue( done );
2359
2360	$.effects.unshift( element, queuelen, 4 );
2361} );
2362
2363} );
2364
2365/*!
2366 * jQuery UI Effects Highlight @VERSION
2367 * https://jqueryui.com
2368 *
2369 * Copyright OpenJS Foundation and other contributors
2370 * Released under the MIT license.
2371 * https://jquery.org/license
2372 */
2373
2374//>>label: Highlight Effect
2375//>>group: Effects
2376//>>description: Highlights the background of an element in a defined color for a custom duration.
2377//>>docs: https://api.jqueryui.com/highlight-effect/
2378//>>demos: https://jqueryui.com/effect/
2379
2380( function( factory ) {
2381	"use strict";
2382
2383	if ( typeof define === "function" && define.amd ) {
2384
2385		// AMD. Register as an anonymous module.
2386		define( 'ui/effects/effect-highlight.js',[
2387			"jquery",
2388			"../version",
2389			"../effect"
2390		], factory );
2391	} else {
2392
2393		// Browser globals
2394		factory( jQuery );
2395	}
2396} )( function( $ ) {
2397"use strict";
2398
2399return $.effects.define( "highlight", "show", function( options, done ) {
2400	var element = $( this ),
2401		animation = {
2402			backgroundColor: element.css( "backgroundColor" )
2403		};
2404
2405	if ( options.mode === "hide" ) {
2406		animation.opacity = 0;
2407	}
2408
2409	$.effects.saveStyle( element );
2410
2411	element
2412		.css( {
2413			backgroundImage: "none",
2414			backgroundColor: options.color || "#ffff99"
2415		} )
2416		.animate( animation, {
2417			queue: false,
2418			duration: options.duration,
2419			easing: options.easing,
2420			complete: done
2421		} );
2422} );
2423
2424} );
2425
2426/*!
2427 * jQuery UI Effects Size @VERSION
2428 * https://jqueryui.com
2429 *
2430 * Copyright OpenJS Foundation and other contributors
2431 * Released under the MIT license.
2432 * https://jquery.org/license
2433 */
2434
2435//>>label: Size Effect
2436//>>group: Effects
2437//>>description: Resize an element to a specified width and height.
2438//>>docs: https://api.jqueryui.com/size-effect/
2439//>>demos: https://jqueryui.com/effect/
2440
2441( function( factory ) {
2442	"use strict";
2443
2444	if ( typeof define === "function" && define.amd ) {
2445
2446		// AMD. Register as an anonymous module.
2447		define( 'ui/effects/effect-size.js',[
2448			"jquery",
2449			"../version",
2450			"../effect"
2451		], factory );
2452	} else {
2453
2454		// Browser globals
2455		factory( jQuery );
2456	}
2457} )( function( $ ) {
2458"use strict";
2459
2460return $.effects.define( "size", function( options, done ) {
2461
2462	// Create element
2463	var baseline, factor, temp,
2464		element = $( this ),
2465
2466		// Copy for children
2467		cProps = [ "fontSize" ],
2468		vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
2469		hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
2470
2471		// Set options
2472		mode = options.mode,
2473		restore = mode !== "effect",
2474		scale = options.scale || "both",
2475		origin = options.origin || [ "middle", "center" ],
2476		position = element.css( "position" ),
2477		pos = element.position(),
2478		original = $.effects.scaledDimensions( element ),
2479		from = options.from || original,
2480		to = options.to || $.effects.scaledDimensions( element, 0 );
2481
2482	$.effects.createPlaceholder( element );
2483
2484	if ( mode === "show" ) {
2485		temp = from;
2486		from = to;
2487		to = temp;
2488	}
2489
2490	// Set scaling factor
2491	factor = {
2492		from: {
2493			y: from.height / original.height,
2494			x: from.width / original.width
2495		},
2496		to: {
2497			y: to.height / original.height,
2498			x: to.width / original.width
2499		}
2500	};
2501
2502	// Scale the css box
2503	if ( scale === "box" || scale === "both" ) {
2504
2505		// Vertical props scaling
2506		if ( factor.from.y !== factor.to.y ) {
2507			from = $.effects.setTransition( element, vProps, factor.from.y, from );
2508			to = $.effects.setTransition( element, vProps, factor.to.y, to );
2509		}
2510
2511		// Horizontal props scaling
2512		if ( factor.from.x !== factor.to.x ) {
2513			from = $.effects.setTransition( element, hProps, factor.from.x, from );
2514			to = $.effects.setTransition( element, hProps, factor.to.x, to );
2515		}
2516	}
2517
2518	// Scale the content
2519	if ( scale === "content" || scale === "both" ) {
2520
2521		// Vertical props scaling
2522		if ( factor.from.y !== factor.to.y ) {
2523			from = $.effects.setTransition( element, cProps, factor.from.y, from );
2524			to = $.effects.setTransition( element, cProps, factor.to.y, to );
2525		}
2526	}
2527
2528	// Adjust the position properties based on the provided origin points
2529	if ( origin ) {
2530		baseline = $.effects.getBaseline( origin, original );
2531		from.top = ( original.outerHeight - from.outerHeight ) * baseline.y + pos.top;
2532		from.left = ( original.outerWidth - from.outerWidth ) * baseline.x + pos.left;
2533		to.top = ( original.outerHeight - to.outerHeight ) * baseline.y + pos.top;
2534		to.left = ( original.outerWidth - to.outerWidth ) * baseline.x + pos.left;
2535	}
2536	delete from.outerHeight;
2537	delete from.outerWidth;
2538	element.css( from );
2539
2540	// Animate the children if desired
2541	if ( scale === "content" || scale === "both" ) {
2542
2543		vProps = vProps.concat( [ "marginTop", "marginBottom" ] ).concat( cProps );
2544		hProps = hProps.concat( [ "marginLeft", "marginRight" ] );
2545
2546		// Only animate children with width attributes specified
2547		// TODO: is this right? should we include anything with css width specified as well
2548		element.find( "*[width]" ).each( function() {
2549			var child = $( this ),
2550				childOriginal = $.effects.scaledDimensions( child ),
2551				childFrom = {
2552					height: childOriginal.height * factor.from.y,
2553					width: childOriginal.width * factor.from.x,
2554					outerHeight: childOriginal.outerHeight * factor.from.y,
2555					outerWidth: childOriginal.outerWidth * factor.from.x
2556				},
2557				childTo = {
2558					height: childOriginal.height * factor.to.y,
2559					width: childOriginal.width * factor.to.x,
2560					outerHeight: childOriginal.height * factor.to.y,
2561					outerWidth: childOriginal.width * factor.to.x
2562				};
2563
2564			// Vertical props scaling
2565			if ( factor.from.y !== factor.to.y ) {
2566				childFrom = $.effects.setTransition( child, vProps, factor.from.y, childFrom );
2567				childTo = $.effects.setTransition( child, vProps, factor.to.y, childTo );
2568			}
2569
2570			// Horizontal props scaling
2571			if ( factor.from.x !== factor.to.x ) {
2572				childFrom = $.effects.setTransition( child, hProps, factor.from.x, childFrom );
2573				childTo = $.effects.setTransition( child, hProps, factor.to.x, childTo );
2574			}
2575
2576			if ( restore ) {
2577				$.effects.saveStyle( child );
2578			}
2579
2580			// Animate children
2581			child.css( childFrom );
2582			child.animate( childTo, options.duration, options.easing, function() {
2583
2584				// Restore children
2585				if ( restore ) {
2586					$.effects.restoreStyle( child );
2587				}
2588			} );
2589		} );
2590	}
2591
2592	// Animate
2593	element.animate( to, {
2594		queue: false,
2595		duration: options.duration,
2596		easing: options.easing,
2597		complete: function() {
2598
2599			var offset = element.offset();
2600
2601			if ( to.opacity === 0 ) {
2602				element.css( "opacity", from.opacity );
2603			}
2604
2605			if ( !restore ) {
2606				element
2607					.css( "position", position === "static" ? "relative" : position )
2608					.offset( offset );
2609
2610				// Need to save style here so that automatic style restoration
2611				// doesn't restore to the original styles from before the animation.
2612				$.effects.saveStyle( element );
2613			}
2614
2615			done();
2616		}
2617	} );
2618
2619} );
2620
2621} );
2622
2623/*!
2624 * jQuery UI Effects Scale @VERSION
2625 * https://jqueryui.com
2626 *
2627 * Copyright OpenJS Foundation and other contributors
2628 * Released under the MIT license.
2629 * https://jquery.org/license
2630 */
2631
2632//>>label: Scale Effect
2633//>>group: Effects
2634//>>description: Grows or shrinks an element and its content.
2635//>>docs: https://api.jqueryui.com/scale-effect/
2636//>>demos: https://jqueryui.com/effect/
2637
2638( function( factory ) {
2639	"use strict";
2640
2641	if ( typeof define === "function" && define.amd ) {
2642
2643		// AMD. Register as an anonymous module.
2644		define( 'ui/effects/effect-scale.js',[
2645			"jquery",
2646			"../version",
2647			"../effect",
2648			"./effect-size"
2649		], factory );
2650	} else {
2651
2652		// Browser globals
2653		factory( jQuery );
2654	}
2655} )( function( $ ) {
2656"use strict";
2657
2658return $.effects.define( "scale", function( options, done ) {
2659
2660	// Create element
2661	var el = $( this ),
2662		mode = options.mode,
2663		percent = parseInt( options.percent, 10 ) ||
2664			( parseInt( options.percent, 10 ) === 0 ? 0 : ( mode !== "effect" ? 0 : 100 ) ),
2665
2666		newOptions = $.extend( true, {
2667			from: $.effects.scaledDimensions( el ),
2668			to: $.effects.scaledDimensions( el, percent, options.direction || "both" ),
2669			origin: options.origin || [ "middle", "center" ]
2670		}, options );
2671
2672	// Fade option to support puff
2673	if ( options.fade ) {
2674		newOptions.from.opacity = 1;
2675		newOptions.to.opacity = 0;
2676	}
2677
2678	$.effects.effect.size.call( this, newOptions, done );
2679} );
2680
2681} );
2682
2683/*!
2684 * jQuery UI Effects Puff @VERSION
2685 * https://jqueryui.com
2686 *
2687 * Copyright OpenJS Foundation and other contributors
2688 * Released under the MIT license.
2689 * https://jquery.org/license
2690 */
2691
2692//>>label: Puff Effect
2693//>>group: Effects
2694//>>description: Creates a puff effect by scaling the element up and hiding it at the same time.
2695//>>docs: https://api.jqueryui.com/puff-effect/
2696//>>demos: https://jqueryui.com/effect/
2697
2698( function( factory ) {
2699	"use strict";
2700
2701	if ( typeof define === "function" && define.amd ) {
2702
2703		// AMD. Register as an anonymous module.
2704		define( 'ui/effects/effect-puff.js',[
2705			"jquery",
2706			"../version",
2707			"../effect",
2708			"./effect-scale"
2709		], factory );
2710	} else {
2711
2712		// Browser globals
2713		factory( jQuery );
2714	}
2715} )( function( $ ) {
2716"use strict";
2717
2718return $.effects.define( "puff", "hide", function( options, done ) {
2719	var newOptions = $.extend( true, {}, options, {
2720		fade: true,
2721		percent: parseInt( options.percent, 10 ) || 150
2722	} );
2723
2724	$.effects.effect.scale.call( this, newOptions, done );
2725} );
2726
2727} );
2728
2729/*!
2730 * jQuery UI Effects Pulsate @VERSION
2731 * https://jqueryui.com
2732 *
2733 * Copyright OpenJS Foundation and other contributors
2734 * Released under the MIT license.
2735 * https://jquery.org/license
2736 */
2737
2738//>>label: Pulsate Effect
2739//>>group: Effects
2740//>>description: Pulsates an element n times by changing the opacity to zero and back.
2741//>>docs: https://api.jqueryui.com/pulsate-effect/
2742//>>demos: https://jqueryui.com/effect/
2743
2744( function( factory ) {
2745	"use strict";
2746
2747	if ( typeof define === "function" && define.amd ) {
2748
2749		// AMD. Register as an anonymous module.
2750		define( 'ui/effects/effect-pulsate.js',[
2751			"jquery",
2752			"../version",
2753			"../effect"
2754		], factory );
2755	} else {
2756
2757		// Browser globals
2758		factory( jQuery );
2759	}
2760} )( function( $ ) {
2761"use strict";
2762
2763return $.effects.define( "pulsate", "show", function( options, done ) {
2764	var element = $( this ),
2765		mode = options.mode,
2766		show = mode === "show",
2767		hide = mode === "hide",
2768		showhide = show || hide,
2769
2770		// Showing or hiding leaves off the "last" animation
2771		anims = ( ( options.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
2772		duration = options.duration / anims,
2773		animateTo = 0,
2774		i = 1,
2775		queuelen = element.queue().length;
2776
2777	if ( show || !element.is( ":visible" ) ) {
2778		element.css( "opacity", 0 ).show();
2779		animateTo = 1;
2780	}
2781
2782	// Anims - 1 opacity "toggles"
2783	for ( ; i < anims; i++ ) {
2784		element.animate( { opacity: animateTo }, duration, options.easing );
2785		animateTo = 1 - animateTo;
2786	}
2787
2788	element.animate( { opacity: animateTo }, duration, options.easing );
2789
2790	element.queue( done );
2791
2792	$.effects.unshift( element, queuelen, anims + 1 );
2793} );
2794
2795} );
2796
2797/*!
2798 * jQuery UI Effects Shake @VERSION
2799 * https://jqueryui.com
2800 *
2801 * Copyright OpenJS Foundation and other contributors
2802 * Released under the MIT license.
2803 * https://jquery.org/license
2804 */
2805
2806//>>label: Shake Effect
2807//>>group: Effects
2808//>>description: Shakes an element horizontally or vertically n times.
2809//>>docs: https://api.jqueryui.com/shake-effect/
2810//>>demos: https://jqueryui.com/effect/
2811
2812( function( factory ) {
2813	"use strict";
2814
2815	if ( typeof define === "function" && define.amd ) {
2816
2817		// AMD. Register as an anonymous module.
2818		define( 'ui/effects/effect-shake.js',[
2819			"jquery",
2820			"../version",
2821			"../effect"
2822		], factory );
2823	} else {
2824
2825		// Browser globals
2826		factory( jQuery );
2827	}
2828} )( function( $ ) {
2829"use strict";
2830
2831return $.effects.define( "shake", function( options, done ) {
2832
2833	var i = 1,
2834		element = $( this ),
2835		direction = options.direction || "left",
2836		distance = options.distance || 20,
2837		times = options.times || 3,
2838		anims = times * 2 + 1,
2839		speed = Math.round( options.duration / anims ),
2840		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
2841		positiveMotion = ( direction === "up" || direction === "left" ),
2842		animation = {},
2843		animation1 = {},
2844		animation2 = {},
2845
2846		queuelen = element.queue().length;
2847
2848	$.effects.createPlaceholder( element );
2849
2850	// Animation
2851	animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
2852	animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
2853	animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
2854
2855	// Animate
2856	element.animate( animation, speed, options.easing );
2857
2858	// Shakes
2859	for ( ; i < times; i++ ) {
2860		element
2861			.animate( animation1, speed, options.easing )
2862			.animate( animation2, speed, options.easing );
2863	}
2864
2865	element
2866		.animate( animation1, speed, options.easing )
2867		.animate( animation, speed / 2, options.easing )
2868		.queue( done );
2869
2870	$.effects.unshift( element, queuelen, anims + 1 );
2871} );
2872
2873} );
2874
2875/*!
2876 * jQuery UI Effects Slide @VERSION
2877 * https://jqueryui.com
2878 *
2879 * Copyright OpenJS Foundation and other contributors
2880 * Released under the MIT license.
2881 * https://jquery.org/license
2882 */
2883
2884//>>label: Slide Effect
2885//>>group: Effects
2886//>>description: Slides an element in and out of the viewport.
2887//>>docs: https://api.jqueryui.com/slide-effect/
2888//>>demos: https://jqueryui.com/effect/
2889
2890( function( factory ) {
2891	"use strict";
2892
2893	if ( typeof define === "function" && define.amd ) {
2894
2895		// AMD. Register as an anonymous module.
2896		define( 'ui/effects/effect-slide.js',[
2897			"jquery",
2898			"../version",
2899			"../effect"
2900		], factory );
2901	} else {
2902
2903		// Browser globals
2904		factory( jQuery );
2905	}
2906} )( function( $ ) {
2907"use strict";
2908
2909return $.effects.define( "slide", "show", function( options, done ) {
2910	var startClip, startRef,
2911		element = $( this ),
2912		map = {
2913			up: [ "bottom", "top" ],
2914			down: [ "top", "bottom" ],
2915			left: [ "right", "left" ],
2916			right: [ "left", "right" ]
2917		},
2918		mode = options.mode,
2919		direction = options.direction || "left",
2920		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
2921		positiveMotion = ( direction === "up" || direction === "left" ),
2922		distance = options.distance ||
2923			element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ),
2924		animation = {};
2925
2926	$.effects.createPlaceholder( element );
2927
2928	startClip = element.cssClip();
2929	startRef = element.position()[ ref ];
2930
2931	// Define hide animation
2932	animation[ ref ] = ( positiveMotion ? -1 : 1 ) * distance + startRef;
2933	animation.clip = element.cssClip();
2934	animation.clip[ map[ direction ][ 1 ] ] = animation.clip[ map[ direction ][ 0 ] ];
2935
2936	// Reverse the animation if we're showing
2937	if ( mode === "show" ) {
2938		element.cssClip( animation.clip );
2939		element.css( ref, animation[ ref ] );
2940		animation.clip = startClip;
2941		animation[ ref ] = startRef;
2942	}
2943
2944	// Actually animate
2945	element.animate( animation, {
2946		queue: false,
2947		duration: options.duration,
2948		easing: options.easing,
2949		complete: done
2950	} );
2951} );
2952
2953} );
2954
2955/*!
2956 * jQuery UI Effects Transfer @VERSION
2957 * https://jqueryui.com
2958 *
2959 * Copyright OpenJS Foundation and other contributors
2960 * Released under the MIT license.
2961 * https://jquery.org/license
2962 */
2963
2964//>>label: Transfer Effect
2965//>>group: Effects
2966//>>description: Displays a transfer effect from one element to another.
2967//>>docs: https://api.jqueryui.com/transfer-effect/
2968//>>demos: https://jqueryui.com/effect/
2969
2970( function( factory ) {
2971	"use strict";
2972
2973	if ( typeof define === "function" && define.amd ) {
2974
2975		// AMD. Register as an anonymous module.
2976		define( 'ui/effects/effect-transfer.js',[
2977			"jquery",
2978			"../version",
2979			"../effect"
2980		], factory );
2981	} else {
2982
2983		// Browser globals
2984		factory( jQuery );
2985	}
2986} )( function( $ ) {
2987"use strict";
2988
2989var effect;
2990if ( $.uiBackCompat === true ) {
2991	effect = $.effects.define( "transfer", function( options, done ) {
2992		$( this ).transfer( options, done );
2993	} );
2994}
2995return effect;
2996
2997} );
2998
2999/*!
3000 * jQuery UI Focusable @VERSION
3001 * https://jqueryui.com
3002 *
3003 * Copyright OpenJS Foundation and other contributors
3004 * Released under the MIT license.
3005 * https://jquery.org/license
3006 */
3007
3008//>>label: :focusable Selector
3009//>>group: Core
3010//>>description: Selects elements which can be focused.
3011//>>docs: https://api.jqueryui.com/focusable-selector/
3012
3013( function( factory ) {
3014	"use strict";
3015
3016	if ( typeof define === "function" && define.amd ) {
3017
3018		// AMD. Register as an anonymous module.
3019		define( 'ui/focusable',[ "jquery", "./version" ], factory );
3020	} else {
3021
3022		// Browser globals
3023		factory( jQuery );
3024	}
3025} )( function( $ ) {
3026"use strict";
3027
3028// Selectors
3029$.ui.focusable = function( element, hasTabindex ) {
3030	var map, mapName, img, focusableIfVisible, fieldset,
3031		nodeName = element.nodeName.toLowerCase();
3032
3033	if ( "area" === nodeName ) {
3034		map = element.parentNode;
3035		mapName = map.name;
3036		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
3037			return false;
3038		}
3039		img = $( "img[usemap='#" + mapName + "']" );
3040		return img.length > 0 && img.is( ":visible" );
3041	}
3042
3043	if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
3044		focusableIfVisible = !element.disabled;
3045
3046		if ( focusableIfVisible ) {
3047
3048			// Form controls within a disabled fieldset are disabled.
3049			// However, controls within the fieldset's legend do not get disabled.
3050			// Since controls generally aren't placed inside legends, we skip
3051			// this portion of the check.
3052			fieldset = $( element ).closest( "fieldset" )[ 0 ];
3053			if ( fieldset ) {
3054				focusableIfVisible = !fieldset.disabled;
3055			}
3056		}
3057	} else if ( "a" === nodeName ) {
3058		focusableIfVisible = element.href || hasTabindex;
3059	} else {
3060		focusableIfVisible = hasTabindex;
3061	}
3062
3063	return focusableIfVisible && $( element ).is( ":visible" ) &&
3064		$( element ).css( "visibility" ) === "visible";
3065};
3066
3067$.extend( $.expr.pseudos, {
3068	focusable: function( element ) {
3069		return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
3070	}
3071} );
3072
3073return $.ui.focusable;
3074
3075} );
3076
3077/*!
3078 * jQuery UI Form Reset Mixin @VERSION
3079 * https://jqueryui.com
3080 *
3081 * Copyright OpenJS Foundation and other contributors
3082 * Released under the MIT license.
3083 * https://jquery.org/license
3084 */
3085
3086//>>label: Form Reset Mixin
3087//>>group: Core
3088//>>description: Refresh input widgets when their form is reset
3089//>>docs: https://api.jqueryui.com/form-reset-mixin/
3090
3091( function( factory ) {
3092	"use strict";
3093
3094	if ( typeof define === "function" && define.amd ) {
3095
3096		// AMD. Register as an anonymous module.
3097		define( 'ui/form-reset-mixin',[
3098			"jquery",
3099			"./version"
3100		], factory );
3101	} else {
3102
3103		// Browser globals
3104		factory( jQuery );
3105	}
3106} )( function( $ ) {
3107"use strict";
3108
3109return $.ui.formResetMixin = {
3110	_formResetHandler: function() {
3111		var form = $( this );
3112
3113		// Wait for the form reset to actually happen before refreshing
3114		setTimeout( function() {
3115			var instances = form.data( "ui-form-reset-instances" );
3116			$.each( instances, function() {
3117				this.refresh();
3118			} );
3119		} );
3120	},
3121
3122	_bindFormResetHandler: function() {
3123		this.form = $( this.element.prop( "form" ) );
3124		if ( !this.form.length ) {
3125			return;
3126		}
3127
3128		var instances = this.form.data( "ui-form-reset-instances" ) || [];
3129		if ( !instances.length ) {
3130
3131			// We don't use _on() here because we use a single event handler per form
3132			this.form.on( "reset.ui-form-reset", this._formResetHandler );
3133		}
3134		instances.push( this );
3135		this.form.data( "ui-form-reset-instances", instances );
3136	},
3137
3138	_unbindFormResetHandler: function() {
3139		if ( !this.form.length ) {
3140			return;
3141		}
3142
3143		var instances = this.form.data( "ui-form-reset-instances" );
3144		instances.splice( $.inArray( this, instances ), 1 );
3145		if ( instances.length ) {
3146			this.form.data( "ui-form-reset-instances", instances );
3147		} else {
3148			this.form
3149				.removeData( "ui-form-reset-instances" )
3150				.off( "reset.ui-form-reset" );
3151		}
3152	}
3153};
3154
3155} );
3156
3157/*!
3158 * jQuery UI Legacy jQuery Core patches @VERSION
3159 * https://jqueryui.com
3160 *
3161 * Copyright OpenJS Foundation and other contributors
3162 * Released under the MIT license.
3163 * https://jquery.org/license
3164 *
3165 */
3166
3167//>>label: Legacy jQuery Core patches
3168//>>group: Core
3169//>>description: Backport `.even()`, `.odd()` and `$.escapeSelector` to older jQuery Core versions (deprecated)
3170
3171( function( factory ) {
3172"use strict";
3173
3174	if ( typeof define === "function" && define.amd ) {
3175
3176		// AMD. Register as an anonymous module.
3177		define( 'ui/jquery-patch.js',[ "jquery", "./version" ], factory );
3178	} else {
3179
3180		// Browser globals
3181		factory( jQuery );
3182	}
3183} )( function( $ ) {
3184"use strict";
3185
3186// Support: jQuery 2.2.x or older.
3187// This method has been defined in jQuery 3.0.0.
3188// Code from https://github.com/jquery/jquery/blob/e539bac79e666bba95bba86d690b4e609dca2286/src/selector/escapeSelector.js
3189if ( !$.escapeSelector ) {
3190	$.escapeSelector = function( id ) {
3191		return CSS.escape( id + "" );
3192	};
3193}
3194
3195// Support: jQuery 3.4.x or older
3196// These methods have been defined in jQuery 3.5.0.
3197if ( !$.fn.even || !$.fn.odd ) {
3198	$.fn.extend( {
3199		even: function() {
3200			return this.filter( function( i ) {
3201				return i % 2 === 0;
3202			} );
3203		},
3204		odd: function() {
3205			return this.filter( function( i ) {
3206				return i % 2 === 1;
3207			} );
3208		}
3209	} );
3210}
3211
3212} );
3213
3214/*!
3215 * jQuery UI Keycode @VERSION
3216 * https://jqueryui.com
3217 *
3218 * Copyright OpenJS Foundation and other contributors
3219 * Released under the MIT license.
3220 * https://jquery.org/license
3221 */
3222
3223//>>label: Keycode
3224//>>group: Core
3225//>>description: Provide keycodes as keynames
3226//>>docs: https://api.jqueryui.com/jQuery.ui.keyCode/
3227
3228( function( factory ) {
3229	"use strict";
3230
3231	if ( typeof define === "function" && define.amd ) {
3232
3233		// AMD. Register as an anonymous module.
3234		define( 'ui/keycode',[ "jquery", "./version" ], factory );
3235	} else {
3236
3237		// Browser globals
3238		factory( jQuery );
3239	}
3240} )( function( $ ) {
3241"use strict";
3242
3243return $.ui.keyCode = {
3244	BACKSPACE: 8,
3245	COMMA: 188,
3246	DELETE: 46,
3247	DOWN: 40,
3248	END: 35,
3249	ENTER: 13,
3250	ESCAPE: 27,
3251	HOME: 36,
3252	LEFT: 37,
3253	PAGE_DOWN: 34,
3254	PAGE_UP: 33,
3255	PERIOD: 190,
3256	RIGHT: 39,
3257	SPACE: 32,
3258	TAB: 9,
3259	UP: 38
3260};
3261
3262} );
3263
3264/*!
3265 * jQuery UI Labels @VERSION
3266 * https://jqueryui.com
3267 *
3268 * Copyright OpenJS Foundation and other contributors
3269 * Released under the MIT license.
3270 * https://jquery.org/license
3271 */
3272
3273//>>label: labels
3274//>>group: Core
3275//>>description: Find all the labels associated with a given input
3276//>>docs: https://api.jqueryui.com/labels/
3277
3278( function( factory ) {
3279	"use strict";
3280
3281	if ( typeof define === "function" && define.amd ) {
3282
3283		// AMD. Register as an anonymous module.
3284		define( 'ui/labels',[ "jquery", "./version" ], factory );
3285	} else {
3286
3287		// Browser globals
3288		factory( jQuery );
3289	}
3290} )( function( $ ) {
3291"use strict";
3292
3293return $.fn.labels = function() {
3294	var ancestor, selector, id, labels, ancestors;
3295
3296	if ( !this.length ) {
3297		return this.pushStack( [] );
3298	}
3299
3300	// Check control.labels first
3301	if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
3302		return this.pushStack( this[ 0 ].labels );
3303	}
3304
3305	// If `control.labels` is empty - e.g. inside of document fragments - find
3306	// the labels manually
3307	labels = this.eq( 0 ).parents( "label" );
3308
3309	// Look for the label based on the id
3310	id = this.attr( "id" );
3311	if ( id ) {
3312
3313		// We don't search against the document in case the element
3314		// is disconnected from the DOM
3315		ancestor = this.eq( 0 ).parents().last();
3316
3317		// Get a full set of top level ancestors
3318		ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
3319
3320		// Create a selector for the label based on the id
3321		selector = "label[for='" + CSS.escape( id ) + "']";
3322
3323		labels = labels.add( ancestors.find( selector ).addBack( selector ) );
3324
3325	}
3326
3327	// Return whatever we have found for labels
3328	return this.pushStack( labels );
3329};
3330
3331} );
3332
3333( function( factory ) {
3334	"use strict";
3335
3336	if ( typeof define === "function" && define.amd ) {
3337
3338		// AMD. Register as an anonymous module.
3339		define( 'ui/plugin',[ "jquery", "./version" ], factory );
3340	} else {
3341
3342		// Browser globals
3343		factory( jQuery );
3344	}
3345} )( function( $ ) {
3346"use strict";
3347
3348// $.ui.plugin is deprecated. Use $.widget() extensions instead.
3349return $.ui.plugin = {
3350	add: function( module, option, set ) {
3351		var i,
3352			proto = $.ui[ module ].prototype;
3353		for ( i in set ) {
3354			proto.plugins[ i ] = proto.plugins[ i ] || [];
3355			proto.plugins[ i ].push( [ option, set[ i ] ] );
3356		}
3357	},
3358	call: function( instance, name, args, allowDisconnected ) {
3359		var i,
3360			set = instance.plugins[ name ];
3361
3362		if ( !set ) {
3363			return;
3364		}
3365
3366		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode ||
3367				instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
3368			return;
3369		}
3370
3371		for ( i = 0; i < set.length; i++ ) {
3372			if ( instance.options[ set[ i ][ 0 ] ] ) {
3373				set[ i ][ 1 ].apply( instance.element, args );
3374			}
3375		}
3376	}
3377};
3378
3379} );
3380
3381/*!
3382 * jQuery UI Position @VERSION
3383 * https://jqueryui.com
3384 *
3385 * Copyright OpenJS Foundation and other contributors
3386 * Released under the MIT license.
3387 * https://jquery.org/license
3388 *
3389 * https://api.jqueryui.com/position/
3390 */
3391
3392//>>label: Position
3393//>>group: Core
3394//>>description: Positions elements relative to other elements.
3395//>>docs: https://api.jqueryui.com/position/
3396//>>demos: https://jqueryui.com/position/
3397
3398( function( factory ) {
3399	"use strict";
3400
3401	if ( typeof define === "function" && define.amd ) {
3402
3403		// AMD. Register as an anonymous module.
3404		define( 'ui/position',[ "jquery", "./version" ], factory );
3405	} else {
3406
3407		// Browser globals
3408		factory( jQuery );
3409	}
3410} )( function( $ ) {
3411"use strict";
3412
3413( function() {
3414var cachedScrollbarWidth,
3415	max = Math.max,
3416	abs = Math.abs,
3417	rhorizontal = /left|center|right/,
3418	rvertical = /top|center|bottom/,
3419	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
3420	rposition = /^\w+/,
3421	rpercent = /%$/,
3422	_position = $.fn.position;
3423
3424function getOffsets( offsets, width, height ) {
3425	return [
3426		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
3427		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
3428	];
3429}
3430
3431function parseCss( element, property ) {
3432	return parseInt( $.css( element, property ), 10 ) || 0;
3433}
3434
3435function isWindow( obj ) {
3436	return obj != null && obj === obj.window;
3437}
3438
3439function getDimensions( elem ) {
3440	var raw = elem[ 0 ];
3441	if ( raw.nodeType === 9 ) {
3442		return {
3443			width: elem.width(),
3444			height: elem.height(),
3445			offset: { top: 0, left: 0 }
3446		};
3447	}
3448	if ( isWindow( raw ) ) {
3449		return {
3450			width: elem.width(),
3451			height: elem.height(),
3452			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
3453		};
3454	}
3455	if ( raw.preventDefault ) {
3456		return {
3457			width: 0,
3458			height: 0,
3459			offset: { top: raw.pageY, left: raw.pageX }
3460		};
3461	}
3462	return {
3463		width: elem.outerWidth(),
3464		height: elem.outerHeight(),
3465		offset: elem.offset()
3466	};
3467}
3468
3469$.position = {
3470	scrollbarWidth: function() {
3471		if ( cachedScrollbarWidth !== undefined ) {
3472			return cachedScrollbarWidth;
3473		}
3474		var w1, w2,
3475			div = $( "<div style=" +
3476				"'display:block;position:absolute;width:200px;height:200px;overflow:hidden;'>" +
3477				"<div style='height:300px;width:auto;'></div></div>" ),
3478			innerDiv = div.children()[ 0 ];
3479
3480		$( "body" ).append( div );
3481		w1 = innerDiv.offsetWidth;
3482		div.css( "overflow", "scroll" );
3483
3484		w2 = innerDiv.offsetWidth;
3485
3486		if ( w1 === w2 ) {
3487			w2 = div[ 0 ].clientWidth;
3488		}
3489
3490		div.remove();
3491
3492		return ( cachedScrollbarWidth = w1 - w2 );
3493	},
3494	getScrollInfo: function( within ) {
3495		var overflowX = within.isWindow || within.isDocument ? "" :
3496				within.element.css( "overflow-x" ),
3497			overflowY = within.isWindow || within.isDocument ? "" :
3498				within.element.css( "overflow-y" ),
3499			hasOverflowX = overflowX === "scroll" ||
3500				( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
3501			hasOverflowY = overflowY === "scroll" ||
3502				( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
3503		return {
3504			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
3505			height: hasOverflowX ? $.position.scrollbarWidth() : 0
3506		};
3507	},
3508	getWithinInfo: function( element ) {
3509		var withinElement = $( element || window ),
3510			isElemWindow = isWindow( withinElement[ 0 ] ),
3511			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
3512			hasOffset = !isElemWindow && !isDocument;
3513		return {
3514			element: withinElement,
3515			isWindow: isElemWindow,
3516			isDocument: isDocument,
3517			offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
3518			scrollLeft: withinElement.scrollLeft(),
3519			scrollTop: withinElement.scrollTop(),
3520			width: withinElement.outerWidth(),
3521			height: withinElement.outerHeight()
3522		};
3523	}
3524};
3525
3526$.fn.position = function( options ) {
3527	if ( !options || !options.of ) {
3528		return _position.apply( this, arguments );
3529	}
3530
3531	// Make a copy, we don't want to modify arguments
3532	options = $.extend( {}, options );
3533
3534	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
3535
3536		// Make sure string options are treated as CSS selectors
3537		target = typeof options.of === "string" ?
3538			$( document ).find( options.of ) :
3539			$( options.of ),
3540
3541		within = $.position.getWithinInfo( options.within ),
3542		scrollInfo = $.position.getScrollInfo( within ),
3543		collision = ( options.collision || "flip" ).split( " " ),
3544		offsets = {};
3545
3546	dimensions = getDimensions( target );
3547	if ( target[ 0 ].preventDefault ) {
3548
3549		// Force left top to allow flipping
3550		options.at = "left top";
3551	}
3552	targetWidth = dimensions.width;
3553	targetHeight = dimensions.height;
3554	targetOffset = dimensions.offset;
3555
3556	// Clone to reuse original targetOffset later
3557	basePosition = $.extend( {}, targetOffset );
3558
3559	// Force my and at to have valid horizontal and vertical positions
3560	// if a value is missing or invalid, it will be converted to center
3561	$.each( [ "my", "at" ], function() {
3562		var pos = ( options[ this ] || "" ).split( " " ),
3563			horizontalOffset,
3564			verticalOffset;
3565
3566		if ( pos.length === 1 ) {
3567			pos = rhorizontal.test( pos[ 0 ] ) ?
3568				pos.concat( [ "center" ] ) :
3569				rvertical.test( pos[ 0 ] ) ?
3570					[ "center" ].concat( pos ) :
3571					[ "center", "center" ];
3572		}
3573		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
3574		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
3575
3576		// Calculate offsets
3577		horizontalOffset = roffset.exec( pos[ 0 ] );
3578		verticalOffset = roffset.exec( pos[ 1 ] );
3579		offsets[ this ] = [
3580			horizontalOffset ? horizontalOffset[ 0 ] : 0,
3581			verticalOffset ? verticalOffset[ 0 ] : 0
3582		];
3583
3584		// Reduce to just the positions without the offsets
3585		options[ this ] = [
3586			rposition.exec( pos[ 0 ] )[ 0 ],
3587			rposition.exec( pos[ 1 ] )[ 0 ]
3588		];
3589	} );
3590
3591	// Normalize collision option
3592	if ( collision.length === 1 ) {
3593		collision[ 1 ] = collision[ 0 ];
3594	}
3595
3596	if ( options.at[ 0 ] === "right" ) {
3597		basePosition.left += targetWidth;
3598	} else if ( options.at[ 0 ] === "center" ) {
3599		basePosition.left += targetWidth / 2;
3600	}
3601
3602	if ( options.at[ 1 ] === "bottom" ) {
3603		basePosition.top += targetHeight;
3604	} else if ( options.at[ 1 ] === "center" ) {
3605		basePosition.top += targetHeight / 2;
3606	}
3607
3608	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
3609	basePosition.left += atOffset[ 0 ];
3610	basePosition.top += atOffset[ 1 ];
3611
3612	return this.each( function() {
3613		var collisionPosition, using,
3614			elem = $( this ),
3615			elemWidth = elem.outerWidth(),
3616			elemHeight = elem.outerHeight(),
3617			marginLeft = parseCss( this, "marginLeft" ),
3618			marginTop = parseCss( this, "marginTop" ),
3619			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
3620				scrollInfo.width,
3621			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
3622				scrollInfo.height,
3623			position = $.extend( {}, basePosition ),
3624			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
3625
3626		if ( options.my[ 0 ] === "right" ) {
3627			position.left -= elemWidth;
3628		} else if ( options.my[ 0 ] === "center" ) {
3629			position.left -= elemWidth / 2;
3630		}
3631
3632		if ( options.my[ 1 ] === "bottom" ) {
3633			position.top -= elemHeight;
3634		} else if ( options.my[ 1 ] === "center" ) {
3635			position.top -= elemHeight / 2;
3636		}
3637
3638		position.left += myOffset[ 0 ];
3639		position.top += myOffset[ 1 ];
3640
3641		collisionPosition = {
3642			marginLeft: marginLeft,
3643			marginTop: marginTop
3644		};
3645
3646		$.each( [ "left", "top" ], function( i, dir ) {
3647			if ( $.ui.position[ collision[ i ] ] ) {
3648				$.ui.position[ collision[ i ] ][ dir ]( position, {
3649					targetWidth: targetWidth,
3650					targetHeight: targetHeight,
3651					elemWidth: elemWidth,
3652					elemHeight: elemHeight,
3653					collisionPosition: collisionPosition,
3654					collisionWidth: collisionWidth,
3655					collisionHeight: collisionHeight,
3656					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
3657					my: options.my,
3658					at: options.at,
3659					within: within,
3660					elem: elem
3661				} );
3662			}
3663		} );
3664
3665		if ( options.using ) {
3666
3667			// Adds feedback as second argument to using callback, if present
3668			using = function( props ) {
3669				var left = targetOffset.left - position.left,
3670					right = left + targetWidth - elemWidth,
3671					top = targetOffset.top - position.top,
3672					bottom = top + targetHeight - elemHeight,
3673					feedback = {
3674						target: {
3675							element: target,
3676							left: targetOffset.left,
3677							top: targetOffset.top,
3678							width: targetWidth,
3679							height: targetHeight
3680						},
3681						element: {
3682							element: elem,
3683							left: position.left,
3684							top: position.top,
3685							width: elemWidth,
3686							height: elemHeight
3687						},
3688						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
3689						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
3690					};
3691				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
3692					feedback.horizontal = "center";
3693				}
3694				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
3695					feedback.vertical = "middle";
3696				}
3697				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
3698					feedback.important = "horizontal";
3699				} else {
3700					feedback.important = "vertical";
3701				}
3702				options.using.call( this, props, feedback );
3703			};
3704		}
3705
3706		elem.offset( $.extend( position, { using: using } ) );
3707	} );
3708};
3709
3710$.ui.position = {
3711	fit: {
3712		left: function( position, data ) {
3713			var within = data.within,
3714				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
3715				outerWidth = within.width,
3716				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
3717				overLeft = withinOffset - collisionPosLeft,
3718				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
3719				newOverRight;
3720
3721			// Element is wider than within
3722			if ( data.collisionWidth > outerWidth ) {
3723
3724				// Element is initially over the left side of within
3725				if ( overLeft > 0 && overRight <= 0 ) {
3726					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
3727						withinOffset;
3728					position.left += overLeft - newOverRight;
3729
3730				// Element is initially over right side of within
3731				} else if ( overRight > 0 && overLeft <= 0 ) {
3732					position.left = withinOffset;
3733
3734				// Element is initially over both left and right sides of within
3735				} else {
3736					if ( overLeft > overRight ) {
3737						position.left = withinOffset + outerWidth - data.collisionWidth;
3738					} else {
3739						position.left = withinOffset;
3740					}
3741				}
3742
3743			// Too far left -> align with left edge
3744			} else if ( overLeft > 0 ) {
3745				position.left += overLeft;
3746
3747			// Too far right -> align with right edge
3748			} else if ( overRight > 0 ) {
3749				position.left -= overRight;
3750
3751			// Adjust based on position and margin
3752			} else {
3753				position.left = max( position.left - collisionPosLeft, position.left );
3754			}
3755		},
3756		top: function( position, data ) {
3757			var within = data.within,
3758				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
3759				outerHeight = data.within.height,
3760				collisionPosTop = position.top - data.collisionPosition.marginTop,
3761				overTop = withinOffset - collisionPosTop,
3762				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
3763				newOverBottom;
3764
3765			// Element is taller than within
3766			if ( data.collisionHeight > outerHeight ) {
3767
3768				// Element is initially over the top of within
3769				if ( overTop > 0 && overBottom <= 0 ) {
3770					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
3771						withinOffset;
3772					position.top += overTop - newOverBottom;
3773
3774				// Element is initially over bottom of within
3775				} else if ( overBottom > 0 && overTop <= 0 ) {
3776					position.top = withinOffset;
3777
3778				// Element is initially over both top and bottom of within
3779				} else {
3780					if ( overTop > overBottom ) {
3781						position.top = withinOffset + outerHeight - data.collisionHeight;
3782					} else {
3783						position.top = withinOffset;
3784					}
3785				}
3786
3787			// Too far up -> align with top
3788			} else if ( overTop > 0 ) {
3789				position.top += overTop;
3790
3791			// Too far down -> align with bottom edge
3792			} else if ( overBottom > 0 ) {
3793				position.top -= overBottom;
3794
3795			// Adjust based on position and margin
3796			} else {
3797				position.top = max( position.top - collisionPosTop, position.top );
3798			}
3799		}
3800	},
3801	flip: {
3802		left: function( position, data ) {
3803			var within = data.within,
3804				withinOffset = within.offset.left + within.scrollLeft,
3805				outerWidth = within.width,
3806				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
3807				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
3808				overLeft = collisionPosLeft - offsetLeft,
3809				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
3810				myOffset = data.my[ 0 ] === "left" ?
3811					-data.elemWidth :
3812					data.my[ 0 ] === "right" ?
3813						data.elemWidth :
3814						0,
3815				atOffset = data.at[ 0 ] === "left" ?
3816					data.targetWidth :
3817					data.at[ 0 ] === "right" ?
3818						-data.targetWidth :
3819						0,
3820				offset = -2 * data.offset[ 0 ],
3821				newOverRight,
3822				newOverLeft;
3823
3824			if ( overLeft < 0 ) {
3825				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
3826					outerWidth - withinOffset;
3827				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
3828					position.left += myOffset + atOffset + offset;
3829				}
3830			} else if ( overRight > 0 ) {
3831				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
3832					atOffset + offset - offsetLeft;
3833				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
3834					position.left += myOffset + atOffset + offset;
3835				}
3836			}
3837		},
3838		top: function( position, data ) {
3839			var within = data.within,
3840				withinOffset = within.offset.top + within.scrollTop,
3841				outerHeight = within.height,
3842				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
3843				collisionPosTop = position.top - data.collisionPosition.marginTop,
3844				overTop = collisionPosTop - offsetTop,
3845				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
3846				top = data.my[ 1 ] === "top",
3847				myOffset = top ?
3848					-data.elemHeight :
3849					data.my[ 1 ] === "bottom" ?
3850						data.elemHeight :
3851						0,
3852				atOffset = data.at[ 1 ] === "top" ?
3853					data.targetHeight :
3854					data.at[ 1 ] === "bottom" ?
3855						-data.targetHeight :
3856						0,
3857				offset = -2 * data.offset[ 1 ],
3858				newOverTop,
3859				newOverBottom;
3860			if ( overTop < 0 ) {
3861				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
3862					outerHeight - withinOffset;
3863				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
3864					position.top += myOffset + atOffset + offset;
3865				}
3866			} else if ( overBottom > 0 ) {
3867				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
3868					offset - offsetTop;
3869				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
3870					position.top += myOffset + atOffset + offset;
3871				}
3872			}
3873		}
3874	},
3875	flipfit: {
3876		left: function() {
3877			$.ui.position.flip.left.apply( this, arguments );
3878			$.ui.position.fit.left.apply( this, arguments );
3879		},
3880		top: function() {
3881			$.ui.position.flip.top.apply( this, arguments );
3882			$.ui.position.fit.top.apply( this, arguments );
3883		}
3884	}
3885};
3886
3887} )();
3888
3889return $.ui.position;
3890
3891} );
3892
3893/*!
3894 * jQuery UI Scroll Parent @VERSION
3895 * https://jqueryui.com
3896 *
3897 * Copyright OpenJS Foundation and other contributors
3898 * Released under the MIT license.
3899 * https://jquery.org/license
3900 */
3901
3902//>>label: scrollParent
3903//>>group: Core
3904//>>description: Get the closest ancestor element that is scrollable.
3905//>>docs: https://api.jqueryui.com/scrollParent/
3906
3907( function( factory ) {
3908	"use strict";
3909
3910	if ( typeof define === "function" && define.amd ) {
3911
3912		// AMD. Register as an anonymous module.
3913		define( 'ui/scroll-parent',[ "jquery", "./version" ], factory );
3914	} else {
3915
3916		// Browser globals
3917		factory( jQuery );
3918	}
3919} )( function( $ ) {
3920"use strict";
3921
3922return $.fn.scrollParent = function( includeHidden ) {
3923	var position = this.css( "position" ),
3924		excludeStaticParent = position === "absolute",
3925		overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
3926		scrollParent = this.parents().filter( function() {
3927			var parent = $( this );
3928			if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
3929				return false;