webinterface.git

1) /*! jQuery UI - v1.13.2 - 2022-07-14

2) * http://jqueryui.com

3) * Includes: widget.js, position.js, data.js, disable-selection.js, effect.js, effects/effect-blind.js, effects/effect-bounce.js, effects/effect-clip.js, effects/effect-drop.js, effects/effect-explode.js, effects/effect-fade.js, effects/effect-fold.js, effects/effect-highlight.js, effects/effect-puff.js, effects/effect-pulsate.js, effects/effect-scale.js, effects/effect-shake.js, effects/effect-size.js, effects/effect-slide.js, effects/effect-transfer.js, focusable.js, form-reset-mixin.js, jquery-patch.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/accordion.js, widgets/autocomplete.js, widgets/button.js, widgets/checkboxradio.js, widgets/controlgroup.js, widgets/datepicker.js, widgets/dialog.js, widgets/draggable.js, widgets/droppable.js, widgets/menu.js, widgets/mouse.js, widgets/progressbar.js, widgets/resizable.js, widgets/selectable.js, widgets/selectmenu.js, widgets/slider.js, widgets/sortable.js, widgets/spinner.js, widgets/tabs.js, widgets/tooltip.js
4) * Copyright jQuery Foundation and other contributors; Licensed MIT */

5) 

6) ( function( factory ) {
7) 	"use strict";
8) 	

9) 	if ( typeof define === "function" && define.amd ) {
10) 
11) 		// AMD. Register as an anonymous module.

12) 		define( [ "jquery" ], factory );

13) 	} else {
14) 
15) 		// Browser globals
16) 		factory( jQuery );
17) 	}

18) } )( function( $ ) {
19) "use strict";

20) 
21) $.ui = $.ui || {};
22) 

23) var version = $.ui.version = "1.13.2";

24) 
25) 
26) /*!

27)  * jQuery UI Widget 1.13.2

28)  * http://jqueryui.com
29)  *
30)  * Copyright jQuery Foundation and other contributors
31)  * Released under the MIT license.
32)  * http://jquery.org/license
33)  */
34) 

35) //>>label: Widget
36) //>>group: Core
37) //>>description: Provides a factory for creating stateful widgets with a common API.
38) //>>docs: http://api.jqueryui.com/jQuery.widget/
39) //>>demos: http://jqueryui.com/widget/
40) 

41) 

42) var widgetUuid = 0;
43) var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
44) var widgetSlice = Array.prototype.slice;

45) 

46) $.cleanData = ( function( orig ) {

47) 	return function( elems ) {
48) 		var events, elem, i;

49) 		for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {

50) 

51) 			// Only trigger remove when necessary to save time
52) 			events = $._data( elem, "events" );
53) 			if ( events && events.remove ) {
54) 				$( elem ).triggerHandler( "remove" );
55) 			}

56) 		}
57) 		orig( elems );
58) 	};

59) } )( $.cleanData );

60) 
61) $.widget = function( name, base, prototype ) {

62) 	var existingConstructor, constructor, basePrototype;

63) 

64) 	// ProxiedPrototype allows the provided prototype to remain unmodified
65) 	// so that it can be used as a mixin for multiple widgets (#8876)
66) 	var proxiedPrototype = {};
67) 
68) 	var namespace = name.split( "." )[ 0 ];

69) 	name = name.split( "." )[ 1 ];

70) 	var fullName = namespace + "-" + name;

71) 
72) 	if ( !prototype ) {
73) 		prototype = base;
74) 		base = $.Widget;
75) 	}
76) 

77) 	if ( Array.isArray( prototype ) ) {
78) 		prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
79) 	}
80) 
81) 	// Create selector for plugin
82) 	$.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) {

83) 		return !!$.data( elem, fullName );
84) 	};
85) 
86) 	$[ namespace ] = $[ namespace ] || {};
87) 	existingConstructor = $[ namespace ][ name ];
88) 	constructor = $[ namespace ][ name ] = function( options, element ) {

89) 
90) 		// Allow instantiation without "new" keyword
91) 		if ( !this || !this._createWidget ) {

92) 			return new constructor( options, element );
93) 		}
94) 

95) 		// Allow instantiation without initializing for simple inheritance

96) 		// must use "new" keyword (the code above always passes args)
97) 		if ( arguments.length ) {
98) 			this._createWidget( options, element );
99) 		}
100) 	};

101) 
102) 	// Extend with the existing constructor to carry over any static properties

103) 	$.extend( constructor, existingConstructor, {
104) 		version: prototype.version,

105) 
106) 		// Copy the object used to create the prototype in case we need to

107) 		// redefine the widget later
108) 		_proto: $.extend( {}, prototype ),

109) 
110) 		// Track widgets that inherit from this widget in case this widget is

111) 		// redefined after a widget inherits from it
112) 		_childConstructors: []

113) 	} );

114) 
115) 	basePrototype = new base();

116) 
117) 	// We need to make the options hash a property directly on the new instance

118) 	// otherwise we'll modify the options hash on the prototype that we're
119) 	// inheriting from
120) 	basePrototype.options = $.widget.extend( {}, basePrototype.options );
121) 	$.each( prototype, function( prop, value ) {

122) 		if ( typeof value !== "function" ) {

123) 			proxiedPrototype[ prop ] = value;
124) 			return;
125) 		}

126) 		proxiedPrototype[ prop ] = ( function() {
127) 			function _super() {
128) 				return base.prototype[ prop ].apply( this, arguments );
129) 			}
130) 
131) 			function _superApply( args ) {
132) 				return base.prototype[ prop ].apply( this, args );
133) 			}
134) 

135) 			return function() {

136) 				var __super = this._super;
137) 				var __superApply = this._superApply;
138) 				var returnValue;

139) 
140) 				this._super = _super;
141) 				this._superApply = _superApply;
142) 
143) 				returnValue = value.apply( this, arguments );
144) 
145) 				this._super = __super;
146) 				this._superApply = __superApply;
147) 
148) 				return returnValue;
149) 			};

150) 		} )();
151) 	} );

152) 	constructor.prototype = $.widget.extend( basePrototype, {

153) 

154) 		// TODO: remove support for widgetEventPrefix
155) 		// always use the name + a colon as the prefix, e.g., draggable:start
156) 		// don't prefix for widgets that aren't DOM-based

157) 		widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name

158) 	}, proxiedPrototype, {
159) 		constructor: constructor,
160) 		namespace: namespace,
161) 		widgetName: name,
162) 		widgetFullName: fullName

163) 	} );

164) 
165) 	// If this widget is being redefined then we need to find all widgets that
166) 	// are inheriting from it and redefine all of them so that they inherit from
167) 	// the new version of this widget. We're essentially trying to replace one
168) 	// level in the prototype chain.
169) 	if ( existingConstructor ) {
170) 		$.each( existingConstructor._childConstructors, function( i, child ) {
171) 			var childPrototype = child.prototype;
172) 

173) 			// Redefine the child widget using the same prototype that was

174) 			// originally used, but inherit from the new version of the base

175) 			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
176) 				child._proto );
177) 		} );
178) 
179) 		// Remove the list of existing child constructors from the old constructor

180) 		// so the old child constructors can be garbage collected
181) 		delete existingConstructor._childConstructors;
182) 	} else {
183) 		base._childConstructors.push( constructor );
184) 	}
185) 
186) 	$.widget.bridge( name, constructor );
187) 
188) 	return constructor;
189) };
190) 
191) $.widget.extend = function( target ) {

192) 	var input = widgetSlice.call( arguments, 1 );
193) 	var inputIndex = 0;
194) 	var inputLength = input.length;
195) 	var key;
196) 	var value;
197) 

198) 	for ( ; inputIndex < inputLength; inputIndex++ ) {
199) 		for ( key in input[ inputIndex ] ) {
200) 			value = input[ inputIndex ][ key ];

201) 			if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) {
202) 

203) 				// Clone objects
204) 				if ( $.isPlainObject( value ) ) {
205) 					target[ key ] = $.isPlainObject( target[ key ] ) ?
206) 						$.widget.extend( {}, target[ key ], value ) :

207) 

208) 						// Don't extend strings, arrays, etc. with objects
209) 						$.widget.extend( {}, value );

210) 

211) 				// Copy everything else by reference
212) 				} else {
213) 					target[ key ] = value;
214) 				}
215) 			}
216) 		}
217) 	}
218) 	return target;
219) };
220) 
221) $.widget.bridge = function( name, object ) {
222) 	var fullName = object.prototype.widgetFullName || name;
223) 	$.fn[ name ] = function( options ) {

224) 		var isMethodCall = typeof options === "string";
225) 		var args = widgetSlice.call( arguments, 1 );
226) 		var returnValue = this;

227) 
228) 		if ( isMethodCall ) {

229) 
230) 			// If this is an empty collection, we need to have the instance method
231) 			// return undefined instead of the jQuery instance
232) 			if ( !this.length && options === "instance" ) {
233) 				returnValue = undefined;
234) 			} else {
235) 				this.each( function() {
236) 					var methodValue;
237) 					var instance = $.data( this, fullName );
238) 
239) 					if ( options === "instance" ) {
240) 						returnValue = instance;
241) 						return false;
242) 					}
243) 
244) 					if ( !instance ) {
245) 						return $.error( "cannot call methods on " + name +
246) 							" prior to initialization; " +
247) 							"attempted to call method '" + options + "'" );
248) 					}
249) 
250) 					if ( typeof instance[ options ] !== "function" ||
251) 						options.charAt( 0 ) === "_" ) {
252) 						return $.error( "no such method '" + options + "' for " + name +
253) 							" widget instance" );
254) 					}
255) 
256) 					methodValue = instance[ options ].apply( instance, args );
257) 
258) 					if ( methodValue !== instance && methodValue !== undefined ) {
259) 						returnValue = methodValue && methodValue.jquery ?
260) 							returnValue.pushStack( methodValue.get() ) :
261) 							methodValue;
262) 						return false;
263) 					}
264) 				} );
265) 			}

266) 		} else {
267) 
268) 			// Allow multiple hashes to be passed on init
269) 			if ( args.length ) {

270) 				options = $.widget.extend.apply( null, [ options ].concat( args ) );

271) 			}
272) 

273) 			this.each( function() {

274) 				var instance = $.data( this, fullName );
275) 				if ( instance ) {
276) 					instance.option( options || {} );
277) 					if ( instance._init ) {
278) 						instance._init();
279) 					}
280) 				} else {
281) 					$.data( this, fullName, new object( options, this ) );
282) 				}

283) 			} );

284) 		}
285) 
286) 		return returnValue;
287) 	};
288) };
289) 
290) $.Widget = function( /* options, element */ ) {};
291) $.Widget._childConstructors = [];
292) 
293) $.Widget.prototype = {
294) 	widgetName: "widget",
295) 	widgetEventPrefix: "",
296) 	defaultElement: "<div>",

297) 

298) 	options: {

299) 		classes: {},

300) 		disabled: false,
301) 

302) 		// Callbacks

303) 		create: null
304) 	},

305) 

306) 	_createWidget: function( options, element ) {
307) 		element = $( element || this.defaultElement || this )[ 0 ];
308) 		this.element = $( element );

309) 		this.uuid = widgetUuid++;

310) 		this.eventNamespace = "." + this.widgetName + this.uuid;
311) 
312) 		this.bindings = $();
313) 		this.hoverable = $();
314) 		this.focusable = $();

315) 		this.classesElementLookup = {};

316) 
317) 		if ( element !== this ) {
318) 			$.data( element, this.widgetFullName, this );
319) 			this._on( true, this.element, {
320) 				remove: function( event ) {
321) 					if ( event.target === element ) {
322) 						this.destroy();
323) 					}
324) 				}

325) 			} );

326) 			this.document = $( element.style ?

327) 
328) 				// Element within the document

329) 				element.ownerDocument :

330) 
331) 				// Element is window or document

332) 				element.document || element );

333) 			this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );

334) 		}
335) 
336) 		this.options = $.widget.extend( {},
337) 			this.options,
338) 			this._getCreateOptions(),
339) 			options );
340) 
341) 		this._create();

342) 
343) 		if ( this.options.disabled ) {
344) 			this._setOptionDisabled( this.options.disabled );
345) 		}
346) 

347) 		this._trigger( "create", null, this._getCreateEventData() );
348) 		this._init();
349) 	},

350) 
351) 	_getCreateOptions: function() {
352) 		return {};
353) 	},
354) 

355) 	_getCreateEventData: $.noop,

356) 

357) 	_create: $.noop,

358) 

359) 	_init: $.noop,
360) 
361) 	destroy: function() {

362) 		var that = this;
363) 

364) 		this._destroy();

365) 		$.each( this.classesElementLookup, function( key, value ) {
366) 			that._removeClass( value, key );
367) 		} );
368) 
369) 		// We can probably remove the unbind calls in 2.0

370) 		// all event bindings should go through this._on()
371) 		this.element

372) 			.off( this.eventNamespace )
373) 			.removeData( this.widgetFullName );

374) 		this.widget()

375) 			.off( this.eventNamespace )
376) 			.removeAttr( "aria-disabled" );

377) 

378) 		// Clean up events and states
379) 		this.bindings.off( this.eventNamespace );

380) 	},

381) 

382) 	_destroy: $.noop,
383) 
384) 	widget: function() {
385) 		return this.element;
386) 	},
387) 
388) 	option: function( key, value ) {

389) 		var options = key;
390) 		var parts;
391) 		var curOption;
392) 		var i;

393) 
394) 		if ( arguments.length === 0 ) {

395) 
396) 			// Don't return a reference to the internal hash

397) 			return $.widget.extend( {}, this.options );
398) 		}
399) 
400) 		if ( typeof key === "string" ) {

401) 
402) 			// Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }

403) 			options = {};
404) 			parts = key.split( "." );
405) 			key = parts.shift();
406) 			if ( parts.length ) {
407) 				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
408) 				for ( i = 0; i < parts.length - 1; i++ ) {
409) 					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
410) 					curOption = curOption[ parts[ i ] ];
411) 				}
412) 				key = parts.pop();
413) 				if ( arguments.length === 1 ) {
414) 					return curOption[ key ] === undefined ? null : curOption[ key ];
415) 				}
416) 				curOption[ key ] = value;
417) 			} else {
418) 				if ( arguments.length === 1 ) {
419) 					return this.options[ key ] === undefined ? null : this.options[ key ];
420) 				}
421) 				options[ key ] = value;
422) 			}
423) 		}
424) 
425) 		this._setOptions( options );
426) 
427) 		return this;
428) 	},

429) 

430) 	_setOptions: function( options ) {
431) 		var key;
432) 
433) 		for ( key in options ) {
434) 			this._setOption( key, options[ key ] );
435) 		}
436) 
437) 		return this;
438) 	},

439) 

440) 	_setOption: function( key, value ) {

441) 		if ( key === "classes" ) {
442) 			this._setOptionClasses( value );
443) 		}
444) 

445) 		this.options[ key ] = value;
446) 
447) 		if ( key === "disabled" ) {

448) 			this._setOptionDisabled( value );
449) 		}

450) 

451) 		return this;
452) 	},
453) 
454) 	_setOptionClasses: function( value ) {
455) 		var classKey, elements, currentElements;
456) 
457) 		for ( classKey in value ) {
458) 			currentElements = this.classesElementLookup[ classKey ];
459) 			if ( value[ classKey ] === this.options.classes[ classKey ] ||
460) 					!currentElements ||
461) 					!currentElements.length ) {
462) 				continue;

463) 			}

464) 
465) 			// We are doing this to create a new jQuery object because the _removeClass() call
466) 			// on the next line is going to destroy the reference to the current elements being
467) 			// tracked. We need to save a copy of this collection so that we can add the new classes
468) 			// below.
469) 			elements = $( currentElements.get() );
470) 			this._removeClass( currentElements, classKey );
471) 
472) 			// We don't use _addClass() here, because that uses this.options.classes
473) 			// for generating the string of classes. We want to use the value passed in from
474) 			// _setOption(), this is the new value of the classes option which was passed to
475) 			// _setOption(). We pass this value directly to _classes().
476) 			elements.addClass( this._classes( {
477) 				element: elements,
478) 				keys: classKey,
479) 				classes: value,
480) 				add: true
481) 			} ) );

482) 		}

483) 	},

484) 

485) 	_setOptionDisabled: function( value ) {
486) 		this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
487) 
488) 		// If the widget is becoming disabled, then nothing is interactive
489) 		if ( value ) {
490) 			this._removeClass( this.hoverable, null, "ui-state-hover" );
491) 			this._removeClass( this.focusable, null, "ui-state-focus" );
492) 		}

493) 	},
494) 
495) 	enable: function() {

496) 		return this._setOptions( { disabled: false } );

497) 	},

498) 

499) 	disable: function() {

500) 		return this._setOptions( { disabled: true } );
501) 	},
502) 
503) 	_classes: function( options ) {
504) 		var full = [];
505) 		var that = this;
506) 
507) 		options = $.extend( {
508) 			element: this.element,
509) 			classes: this.options.classes || {}
510) 		}, options );
511) 
512) 		function bindRemoveEvent() {
513) 			var nodesToBind = [];
514) 
515) 			options.element.each( function( _, element ) {
516) 				var isTracked = $.map( that.classesElementLookup, function( elements ) {
517) 					return elements;
518) 				} )
519) 					.some( function( elements ) {
520) 						return elements.is( element );
521) 					} );
522) 
523) 				if ( !isTracked ) {
524) 					nodesToBind.push( element );
525) 				}
526) 			} );
527) 
528) 			that._on( $( nodesToBind ), {
529) 				remove: "_untrackClassesElement"
530) 			} );
531) 		}
532) 
533) 		function processClassString( classes, checkOption ) {
534) 			var current, i;
535) 			for ( i = 0; i < classes.length; i++ ) {
536) 				current = that.classesElementLookup[ classes[ i ] ] || $();
537) 				if ( options.add ) {
538) 					bindRemoveEvent();
539) 					current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
540) 				} else {
541) 					current = $( current.not( options.element ).get() );
542) 				}
543) 				that.classesElementLookup[ classes[ i ] ] = current;
544) 				full.push( classes[ i ] );
545) 				if ( checkOption && options.classes[ classes[ i ] ] ) {
546) 					full.push( options.classes[ classes[ i ] ] );
547) 				}
548) 			}
549) 		}
550) 
551) 		if ( options.keys ) {
552) 			processClassString( options.keys.match( /\S+/g ) || [], true );
553) 		}
554) 		if ( options.extra ) {
555) 			processClassString( options.extra.match( /\S+/g ) || [] );
556) 		}
557) 
558) 		return full.join( " " );
559) 	},
560) 
561) 	_untrackClassesElement: function( event ) {
562) 		var that = this;
563) 		$.each( that.classesElementLookup, function( key, value ) {
564) 			if ( $.inArray( event.target, value ) !== -1 ) {
565) 				that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
566) 			}
567) 		} );
568) 
569) 		this._off( $( event.target ) );
570) 	},
571) 
572) 	_removeClass: function( element, keys, extra ) {
573) 		return this._toggleClass( element, keys, extra, false );
574) 	},
575) 
576) 	_addClass: function( element, keys, extra ) {
577) 		return this._toggleClass( element, keys, extra, true );
578) 	},
579) 
580) 	_toggleClass: function( element, keys, extra, add ) {
581) 		add = ( typeof add === "boolean" ) ? add : extra;
582) 		var shift = ( typeof element === "string" || element === null ),
583) 			options = {
584) 				extra: shift ? keys : extra,
585) 				keys: shift ? element : keys,
586) 				element: shift ? this.element : element,
587) 				add: add
588) 			};
589) 		options.element.toggleClass( this._classes( options ), add );
590) 		return this;

591) 	},
592) 
593) 	_on: function( suppressDisabledCheck, element, handlers ) {

594) 		var delegateElement;
595) 		var instance = this;

596) 

597) 		// No suppressDisabledCheck flag, shuffle arguments

598) 		if ( typeof suppressDisabledCheck !== "boolean" ) {
599) 			handlers = element;
600) 			element = suppressDisabledCheck;
601) 			suppressDisabledCheck = false;
602) 		}
603) 

604) 		// No element argument, shuffle and use this.element

605) 		if ( !handlers ) {
606) 			handlers = element;
607) 			element = this.element;
608) 			delegateElement = this.widget();
609) 		} else {
610) 			element = delegateElement = $( element );
611) 			this.bindings = this.bindings.add( element );
612) 		}
613) 
614) 		$.each( handlers, function( event, handler ) {
615) 			function handlerProxy() {

616) 
617) 				// Allow widgets to customize the disabled handling

618) 				// - disabled as an array instead of boolean
619) 				// - disabled class as method for disabling individual parts
620) 				if ( !suppressDisabledCheck &&
621) 						( instance.options.disabled === true ||

622) 						$( this ).hasClass( "ui-state-disabled" ) ) ) {

623) 					return;
624) 				}
625) 				return ( typeof handler === "string" ? instance[ handler ] : handler )
626) 					.apply( instance, arguments );
627) 			}
628) 

629) 			// Copy the guid so direct unbinding works

630) 			if ( typeof handler !== "string" ) {
631) 				handlerProxy.guid = handler.guid =
632) 					handler.guid || handlerProxy.guid || $.guid++;
633) 			}
634) 

635) 			var match = event.match( /^([\w:-]*)\s*(.*)$/ );
636) 			var eventName = match[ 1 ] + instance.eventNamespace;
637) 			var selector = match[ 2 ];
638) 

639) 			if ( selector ) {

640) 				delegateElement.on( eventName, selector, handlerProxy );

641) 			} else {

642) 				element.on( eventName, handlerProxy );

643) 			}

644) 		} );

645) 	},
646) 
647) 	_off: function( element, eventName ) {

648) 		eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +

649) 			this.eventNamespace;

650) 		element.off( eventName );

651) 
652) 		// Clear the stack to avoid memory leaks (#10056)
653) 		this.bindings = $( this.bindings.not( element ).get() );
654) 		this.focusable = $( this.focusable.not( element ).get() );
655) 		this.hoverable = $( this.hoverable.not( element ).get() );
656) 	},
657) 
658) 	_delay: function( handler, delay ) {
659) 		function handlerProxy() {
660) 			return ( typeof handler === "string" ? instance[ handler ] : handler )
661) 				.apply( instance, arguments );
662) 		}
663) 		var instance = this;
664) 		return setTimeout( handlerProxy, delay || 0 );
665) 	},
666) 
667) 	_hoverable: function( element ) {
668) 		this.hoverable = this.hoverable.add( element );
669) 		this._on( element, {
670) 			mouseenter: function( event ) {

671) 				this._addClass( $( event.currentTarget ), null, "ui-state-hover" );

672) 			},
673) 			mouseleave: function( event ) {

674) 				this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );

675) 			}

676) 		} );

677) 	},
678) 
679) 	_focusable: function( element ) {
680) 		this.focusable = this.focusable.add( element );
681) 		this._on( element, {
682) 			focusin: function( event ) {

683) 				this._addClass( $( event.currentTarget ), null, "ui-state-focus" );

684) 			},
685) 			focusout: function( event ) {

686) 				this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );

687) 			}

688) 		} );

689) 	},
690) 
691) 	_trigger: function( type, event, data ) {

692) 		var prop, orig;
693) 		var callback = this.options[ type ];

694) 
695) 		data = data || {};
696) 		event = $.Event( event );
697) 		event.type = ( type === this.widgetEventPrefix ?
698) 			type :
699) 			this.widgetEventPrefix + type ).toLowerCase();

700) 
701) 		// The original event may come from any element

702) 		// so we need to reset the target on the new event
703) 		event.target = this.element[ 0 ];
704) 

705) 		// Copy original event properties over to the new event

706) 		orig = event.originalEvent;
707) 		if ( orig ) {
708) 			for ( prop in orig ) {
709) 				if ( !( prop in event ) ) {
710) 					event[ prop ] = orig[ prop ];
711) 				}
712) 			}
713) 		}
714) 
715) 		this.element.trigger( event, data );

716) 		return !( typeof callback === "function" &&
717) 			callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||

718) 			event.isDefaultPrevented() );
719) 	}
720) };
721) 
722) $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
723) 	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
724) 		if ( typeof options === "string" ) {
725) 			options = { effect: options };
726) 		}

727) 
728) 		var hasOptions;
729) 		var effectName = !options ?
730) 			method :
731) 			options === true || typeof options === "number" ?
732) 				defaultEffect :
733) 				options.effect || defaultEffect;
734) 

735) 		options = options || {};
736) 		if ( typeof options === "number" ) {
737) 			options = { duration: options };

738) 		} else if ( options === true ) {
739) 			options = {};

740) 		}

741) 

742) 		hasOptions = !$.isEmptyObject( options );
743) 		options.complete = callback;

744) 

745) 		if ( options.delay ) {
746) 			element.delay( options.delay );
747) 		}

748) 

749) 		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
750) 			element[ method ]( options );
751) 		} else if ( effectName !== method && element[ effectName ] ) {
752) 			element[ effectName ]( options.duration, options.easing, callback );
753) 		} else {

754) 			element.queue( function( next ) {

755) 				$( this )[ method ]();
756) 				if ( callback ) {
757) 					callback.call( element[ 0 ] );
758) 				}
759) 				next();

760) 			} );

761) 		}
762) 	};

763) } );

764) 
765) var widget = $.widget;
766) 
767) 
768) /*!

769)  * jQuery UI Position 1.13.2

770)  * http://jqueryui.com
771)  *
772)  * Copyright jQuery Foundation and other contributors
773)  * Released under the MIT license.
774)  * http://jquery.org/license
775)  *
776)  * http://api.jqueryui.com/position/
777)  */
778) 

779) //>>label: Position
780) //>>group: Core
781) //>>description: Positions elements relative to other elements.
782) //>>docs: http://api.jqueryui.com/position/
783) //>>demos: http://jqueryui.com/position/

784) 
785) 

786) ( function() {
787) var cachedScrollbarWidth,

788) 	max = Math.max,
789) 	abs = Math.abs,
790) 	rhorizontal = /left|center|right/,
791) 	rvertical = /top|center|bottom/,
792) 	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
793) 	rposition = /^\w+/,
794) 	rpercent = /%$/,
795) 	_position = $.fn.position;
796) 
797) function getOffsets( offsets, width, height ) {
798) 	return [
799) 		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
800) 		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
801) 	];
802) }
803) 
804) function parseCss( element, property ) {
805) 	return parseInt( $.css( element, property ), 10 ) || 0;
806) }
807) 

808) function isWindow( obj ) {
809) 	return obj != null && obj === obj.window;
810) }
811) 

812) function getDimensions( elem ) {

813) 	var raw = elem[ 0 ];

814) 	if ( raw.nodeType === 9 ) {
815) 		return {
816) 			width: elem.width(),
817) 			height: elem.height(),
818) 			offset: { top: 0, left: 0 }
819) 		};
820) 	}

821) 	if ( isWindow( raw ) ) {

822) 		return {
823) 			width: elem.width(),
824) 			height: elem.height(),
825) 			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
826) 		};
827) 	}
828) 	if ( raw.preventDefault ) {
829) 		return {
830) 			width: 0,
831) 			height: 0,
832) 			offset: { top: raw.pageY, left: raw.pageX }
833) 		};
834) 	}
835) 	return {
836) 		width: elem.outerWidth(),
837) 		height: elem.outerHeight(),
838) 		offset: elem.offset()
839) 	};
840) }
841) 
842) $.position = {
843) 	scrollbarWidth: function() {
844) 		if ( cachedScrollbarWidth !== undefined ) {
845) 			return cachedScrollbarWidth;
846) 		}
847) 		var w1, w2,

848) 			div = $( "<div style=" +
849) 				"'display:block;position:absolute;width:200px;height:200px;overflow:hidden;'>" +
850) 				"<div style='height:300px;width:auto;'></div></div>" ),
851) 			innerDiv = div.children()[ 0 ];

852) 
853) 		$( "body" ).append( div );
854) 		w1 = innerDiv.offsetWidth;
855) 		div.css( "overflow", "scroll" );
856) 
857) 		w2 = innerDiv.offsetWidth;
858) 
859) 		if ( w1 === w2 ) {

860) 			w2 = div[ 0 ].clientWidth;

861) 		}
862) 
863) 		div.remove();
864) 

865) 		return ( cachedScrollbarWidth = w1 - w2 );

866) 	},
867) 	getScrollInfo: function( within ) {
868) 		var overflowX = within.isWindow || within.isDocument ? "" :
869) 				within.element.css( "overflow-x" ),
870) 			overflowY = within.isWindow || within.isDocument ? "" :
871) 				within.element.css( "overflow-y" ),
872) 			hasOverflowX = overflowX === "scroll" ||

873) 				( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),

874) 			hasOverflowY = overflowY === "scroll" ||

875) 				( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );

876) 		return {
877) 			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
878) 			height: hasOverflowX ? $.position.scrollbarWidth() : 0
879) 		};
880) 	},
881) 	getWithinInfo: function( element ) {
882) 		var withinElement = $( element || window ),

883) 			isElemWindow = isWindow( withinElement[ 0 ] ),
884) 			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
885) 			hasOffset = !isElemWindow && !isDocument;

886) 		return {
887) 			element: withinElement,

888) 			isWindow: isElemWindow,

889) 			isDocument: isDocument,

890) 			offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },

891) 			scrollLeft: withinElement.scrollLeft(),
892) 			scrollTop: withinElement.scrollTop(),

893) 			width: withinElement.outerWidth(),
894) 			height: withinElement.outerHeight()

895) 		};
896) 	}
897) };
898) 
899) $.fn.position = function( options ) {
900) 	if ( !options || !options.of ) {
901) 		return _position.apply( this, arguments );
902) 	}
903) 

904) 	// Make a copy, we don't want to modify arguments

905) 	options = $.extend( {}, options );
906) 
907) 	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,

908) 
909) 		// Make sure string options are treated as CSS selectors
910) 		target = typeof options.of === "string" ?
911) 			$( document ).find( options.of ) :
912) 			$( options.of ),
913) 

914) 		within = $.position.getWithinInfo( options.within ),
915) 		scrollInfo = $.position.getScrollInfo( within ),
916) 		collision = ( options.collision || "flip" ).split( " " ),
917) 		offsets = {};
918) 
919) 	dimensions = getDimensions( target );

920) 	if ( target[ 0 ].preventDefault ) {
921) 
922) 		// Force left top to allow flipping

923) 		options.at = "left top";
924) 	}
925) 	targetWidth = dimensions.width;
926) 	targetHeight = dimensions.height;
927) 	targetOffset = dimensions.offset;

928) 
929) 	// Clone to reuse original targetOffset later

930) 	basePosition = $.extend( {}, targetOffset );
931) 

932) 	// Force my and at to have valid horizontal and vertical positions

933) 	// if a value is missing or invalid, it will be converted to center
934) 	$.each( [ "my", "at" ], function() {
935) 		var pos = ( options[ this ] || "" ).split( " " ),
936) 			horizontalOffset,
937) 			verticalOffset;
938) 

939) 		if ( pos.length === 1 ) {

940) 			pos = rhorizontal.test( pos[ 0 ] ) ?
941) 				pos.concat( [ "center" ] ) :
942) 				rvertical.test( pos[ 0 ] ) ?
943) 					[ "center" ].concat( pos ) :
944) 					[ "center", "center" ];
945) 		}
946) 		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
947) 		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
948) 

949) 		// Calculate offsets

950) 		horizontalOffset = roffset.exec( pos[ 0 ] );
951) 		verticalOffset = roffset.exec( pos[ 1 ] );
952) 		offsets[ this ] = [
953) 			horizontalOffset ? horizontalOffset[ 0 ] : 0,
954) 			verticalOffset ? verticalOffset[ 0 ] : 0
955) 		];
956) 

957) 		// Reduce to just the positions without the offsets

958) 		options[ this ] = [
959) 			rposition.exec( pos[ 0 ] )[ 0 ],
960) 			rposition.exec( pos[ 1 ] )[ 0 ]
961) 		];

962) 	} );

963) 

964) 	// Normalize collision option

965) 	if ( collision.length === 1 ) {
966) 		collision[ 1 ] = collision[ 0 ];
967) 	}
968) 
969) 	if ( options.at[ 0 ] === "right" ) {
970) 		basePosition.left += targetWidth;
971) 	} else if ( options.at[ 0 ] === "center" ) {
972) 		basePosition.left += targetWidth / 2;
973) 	}
974) 
975) 	if ( options.at[ 1 ] === "bottom" ) {
976) 		basePosition.top += targetHeight;
977) 	} else if ( options.at[ 1 ] === "center" ) {
978) 		basePosition.top += targetHeight / 2;
979) 	}
980) 
981) 	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
982) 	basePosition.left += atOffset[ 0 ];
983) 	basePosition.top += atOffset[ 1 ];
984) 

985) 	return this.each( function() {

986) 		var collisionPosition, using,
987) 			elem = $( this ),
988) 			elemWidth = elem.outerWidth(),
989) 			elemHeight = elem.outerHeight(),
990) 			marginLeft = parseCss( this, "marginLeft" ),
991) 			marginTop = parseCss( this, "marginTop" ),

992) 			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
993) 				scrollInfo.width,
994) 			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
995) 				scrollInfo.height,

996) 			position = $.extend( {}, basePosition ),
997) 			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
998) 
999) 		if ( options.my[ 0 ] === "right" ) {
1000) 			position.left -= elemWidth;
1001) 		} else if ( options.my[ 0 ] === "center" ) {
1002) 			position.left -= elemWidth / 2;
1003) 		}
1004) 
1005) 		if ( options.my[ 1 ] === "bottom" ) {
1006) 			position.top -= elemHeight;
1007) 		} else if ( options.my[ 1 ] === "center" ) {
1008) 			position.top -= elemHeight / 2;
1009) 		}
1010) 
1011) 		position.left += myOffset[ 0 ];
1012) 		position.top += myOffset[ 1 ];
1013) 
1014) 		collisionPosition = {
1015) 			marginLeft: marginLeft,
1016) 			marginTop: marginTop
1017) 		};
1018) 
1019) 		$.each( [ "left", "top" ], function( i, dir ) {
1020) 			if ( $.ui.position[ collision[ i ] ] ) {
1021) 				$.ui.position[ collision[ i ] ][ dir ]( position, {
1022) 					targetWidth: targetWidth,
1023) 					targetHeight: targetHeight,
1024) 					elemWidth: elemWidth,
1025) 					elemHeight: elemHeight,
1026) 					collisionPosition: collisionPosition,
1027) 					collisionWidth: collisionWidth,
1028) 					collisionHeight: collisionHeight,
1029) 					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1030) 					my: options.my,
1031) 					at: options.at,
1032) 					within: within,
1033) 					elem: elem

1034) 				} );

1035) 			}

1036) 		} );

1037) 
1038) 		if ( options.using ) {

1039) 
1040) 			// Adds feedback as second argument to using callback, if present

1041) 			using = function( props ) {
1042) 				var left = targetOffset.left - position.left,
1043) 					right = left + targetWidth - elemWidth,
1044) 					top = targetOffset.top - position.top,
1045) 					bottom = top + targetHeight - elemHeight,
1046) 					feedback = {
1047) 						target: {
1048) 							element: target,
1049) 							left: targetOffset.left,
1050) 							top: targetOffset.top,
1051) 							width: targetWidth,
1052) 							height: targetHeight
1053) 						},
1054) 						element: {
1055) 							element: elem,
1056) 							left: position.left,
1057) 							top: position.top,
1058) 							width: elemWidth,
1059) 							height: elemHeight
1060) 						},
1061) 						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1062) 						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1063) 					};
1064) 				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1065) 					feedback.horizontal = "center";
1066) 				}
1067) 				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1068) 					feedback.vertical = "middle";
1069) 				}
1070) 				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1071) 					feedback.important = "horizontal";
1072) 				} else {
1073) 					feedback.important = "vertical";
1074) 				}
1075) 				options.using.call( this, props, feedback );
1076) 			};
1077) 		}
1078) 
1079) 		elem.offset( $.extend( position, { using: using } ) );

1080) 	} );

1081) };
1082) 
1083) $.ui.position = {
1084) 	fit: {
1085) 		left: function( position, data ) {
1086) 			var within = data.within,
1087) 				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1088) 				outerWidth = within.width,
1089) 				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1090) 				overLeft = withinOffset - collisionPosLeft,
1091) 				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1092) 				newOverRight;
1093) 

1094) 			// Element is wider than within

1095) 			if ( data.collisionWidth > outerWidth ) {

1096) 
1097) 				// Element is initially over the left side of within

1098) 				if ( overLeft > 0 && overRight <= 0 ) {

1099) 					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
1100) 						withinOffset;

1101) 					position.left += overLeft - newOverRight;

1102) 
1103) 				// Element is initially over right side of within

1104) 				} else if ( overRight > 0 && overLeft <= 0 ) {
1105) 					position.left = withinOffset;

1106) 
1107) 				// Element is initially over both left and right sides of within

1108) 				} else {
1109) 					if ( overLeft > overRight ) {
1110) 						position.left = withinOffset + outerWidth - data.collisionWidth;
1111) 					} else {
1112) 						position.left = withinOffset;
1113) 					}
1114) 				}

1115) 
1116) 			// Too far left -> align with left edge

1117) 			} else if ( overLeft > 0 ) {
1118) 				position.left += overLeft;

1119) 
1120) 			// Too far right -> align with right edge

1121) 			} else if ( overRight > 0 ) {
1122) 				position.left -= overRight;

1123) 
1124) 			// Adjust based on position and margin

1125) 			} else {
1126) 				position.left = max( position.left - collisionPosLeft, position.left );
1127) 			}
1128) 		},
1129) 		top: function( position, data ) {
1130) 			var within = data.within,
1131) 				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1132) 				outerHeight = data.within.height,
1133) 				collisionPosTop = position.top - data.collisionPosition.marginTop,
1134) 				overTop = withinOffset - collisionPosTop,
1135) 				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1136) 				newOverBottom;
1137) 

1138) 			// Element is taller than within

1139) 			if ( data.collisionHeight > outerHeight ) {

1140) 
1141) 				// Element is initially over the top of within

1142) 				if ( overTop > 0 && overBottom <= 0 ) {

1143) 					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
1144) 						withinOffset;

1145) 					position.top += overTop - newOverBottom;

1146) 
1147) 				// Element is initially over bottom of within

1148) 				} else if ( overBottom > 0 && overTop <= 0 ) {
1149) 					position.top = withinOffset;

1150) 
1151) 				// Element is initially over both top and bottom of within

1152) 				} else {
1153) 					if ( overTop > overBottom ) {
1154) 						position.top = withinOffset + outerHeight - data.collisionHeight;
1155) 					} else {
1156) 						position.top = withinOffset;
1157) 					}
1158) 				}

1159) 
1160) 			// Too far up -> align with top

1161) 			} else if ( overTop > 0 ) {
1162) 				position.top += overTop;

1163) 
1164) 			// Too far down -> align with bottom edge

1165) 			} else if ( overBottom > 0 ) {
1166) 				position.top -= overBottom;

1167) 
1168) 			// Adjust based on position and margin

1169) 			} else {
1170) 				position.top = max( position.top - collisionPosTop, position.top );
1171) 			}
1172) 		}
1173) 	},
1174) 	flip: {
1175) 		left: function( position, data ) {
1176) 			var within = data.within,
1177) 				withinOffset = within.offset.left + within.scrollLeft,
1178) 				outerWidth = within.width,
1179) 				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1180) 				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1181) 				overLeft = collisionPosLeft - offsetLeft,
1182) 				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1183) 				myOffset = data.my[ 0 ] === "left" ?
1184) 					-data.elemWidth :
1185) 					data.my[ 0 ] === "right" ?
1186) 						data.elemWidth :
1187) 						0,
1188) 				atOffset = data.at[ 0 ] === "left" ?
1189) 					data.targetWidth :
1190) 					data.at[ 0 ] === "right" ?
1191) 						-data.targetWidth :
1192) 						0,
1193) 				offset = -2 * data.offset[ 0 ],
1194) 				newOverRight,
1195) 				newOverLeft;
1196) 
1197) 			if ( overLeft < 0 ) {

1198) 				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
1199) 					outerWidth - withinOffset;

1200) 				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1201) 					position.left += myOffset + atOffset + offset;
1202) 				}
1203) 			} else if ( overRight > 0 ) {

1204) 				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
1205) 					atOffset + offset - offsetLeft;

1206) 				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1207) 					position.left += myOffset + atOffset + offset;
1208) 				}
1209) 			}
1210) 		},
1211) 		top: function( position, data ) {
1212) 			var within = data.within,
1213) 				withinOffset = within.offset.top + within.scrollTop,
1214) 				outerHeight = within.height,
1215) 				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1216) 				collisionPosTop = position.top - data.collisionPosition.marginTop,
1217) 				overTop = collisionPosTop - offsetTop,
1218) 				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1219) 				top = data.my[ 1 ] === "top",
1220) 				myOffset = top ?
1221) 					-data.elemHeight :
1222) 					data.my[ 1 ] === "bottom" ?
1223) 						data.elemHeight :
1224) 						0,
1225) 				atOffset = data.at[ 1 ] === "top" ?
1226) 					data.targetHeight :
1227) 					data.at[ 1 ] === "bottom" ?
1228) 						-data.targetHeight :
1229) 						0,
1230) 				offset = -2 * data.offset[ 1 ],
1231) 				newOverTop,
1232) 				newOverBottom;
1233) 			if ( overTop < 0 ) {

1234) 				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
1235) 					outerHeight - withinOffset;

1236) 				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1237) 					position.top += myOffset + atOffset + offset;
1238) 				}
1239) 			} else if ( overBottom > 0 ) {

1240) 				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
1241) 					offset - offsetTop;

1242) 				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1243) 					position.top += myOffset + atOffset + offset;
1244) 				}
1245) 			}
1246) 		}
1247) 	},
1248) 	flipfit: {
1249) 		left: function() {
1250) 			$.ui.position.flip.left.apply( this, arguments );
1251) 			$.ui.position.fit.left.apply( this, arguments );
1252) 		},
1253) 		top: function() {
1254) 			$.ui.position.flip.top.apply( this, arguments );
1255) 			$.ui.position.fit.top.apply( this, arguments );
1256) 		}
1257) 	}
1258) };
1259) 

1260) } )();

1261) 
1262) var position = $.ui.position;
1263) 
1264) 
1265) /*!

1266)  * jQuery UI :data 1.13.2

1267)  * http://jqueryui.com
1268)  *
1269)  * Copyright jQuery Foundation and other contributors
1270)  * Released under the MIT license.
1271)  * http://jquery.org/license
1272)  */
1273) 

1274) //>>label: :data Selector
1275) //>>group: Core
1276) //>>description: Selects elements which have data stored under the specified key.
1277) //>>docs: http://api.jqueryui.com/data-selector/

1278) 
1279) 

1280) var data = $.extend( $.expr.pseudos, {
1281) 	data: $.expr.createPseudo ?
1282) 		$.expr.createPseudo( function( dataName ) {
1283) 			return function( elem ) {
1284) 				return !!$.data( elem, dataName );
1285) 			};
1286) 		} ) :

1287) 

1288) 		// Support: jQuery <1.8
1289) 		function( elem, i, match ) {
1290) 			return !!$.data( elem, match[ 3 ] );
1291) 		}
1292) } );

1293) 

1294) /*!
1295)  * jQuery UI Disable Selection 1.13.2
1296)  * http://jqueryui.com
1297)  *
1298)  * Copyright jQuery Foundation and other contributors
1299)  * Released under the MIT license.
1300)  * http://jquery.org/license
1301)  */

1302) 

1303) //>>label: disableSelection
1304) //>>group: Core
1305) //>>description: Disable selection of text content within the set of matched elements.
1306) //>>docs: http://api.jqueryui.com/disableSelection/

1307) 

1308) // This file is deprecated

1309) 

1310) var disableSelection = $.fn.extend( {
1311) 	disableSelection: ( function() {
1312) 		var eventType = "onselectstart" in document.createElement( "div" ) ?
1313) 			"selectstart" :
1314) 			"mousedown";

1315) 

1316) 		return function() {
1317) 			return this.on( eventType + ".ui-disableSelection", function( event ) {
1318) 				event.preventDefault();
1319) 			} );

1320) 		};

1321) 	} )(),

1322) 

1323) 	enableSelection: function() {
1324) 		return this.off( ".ui-disableSelection" );
1325) 	}
1326) } );

1327) 
1328) 
1329) 

1330) // Create a local jQuery because jQuery Color relies on it and the
1331) // global may not exist with AMD and a custom build (#10199).
1332) // This module is a noop if used as a regular AMD module.
1333) // eslint-disable-next-line no-unused-vars
1334) var jQuery = $;

1335) 
1336) 

1337) /*!
1338)  * jQuery Color Animations v2.2.0
1339)  * https://github.com/jquery/jquery-color
1340)  *
1341)  * Copyright OpenJS Foundation and other contributors
1342)  * Released under the MIT license.
1343)  * http://jquery.org/license
1344)  *
1345)  * Date: Sun May 10 09:02:36 2020 +0200
1346)  */

1347) 
1348) 
1349) 

1350) 	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " +
1351) 		"borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",

1352) 

1353) 	class2type = {},
1354) 	toString = class2type.toString,

1355) 

1356) 	// plusequals test for += 100 -= 100
1357) 	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,

1358) 

1359) 	// a set of RE's that can match strings and generate color tuples.
1360) 	stringParsers = [ {
1361) 			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1362) 			parse: function( execResult ) {
1363) 				return [
1364) 					execResult[ 1 ],
1365) 					execResult[ 2 ],
1366) 					execResult[ 3 ],
1367) 					execResult[ 4 ]
1368) 				];

1369) 			}

1370) 		}, {
1371) 			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1372) 			parse: function( execResult ) {
1373) 				return [
1374) 					execResult[ 1 ] * 2.55,
1375) 					execResult[ 2 ] * 2.55,
1376) 					execResult[ 3 ] * 2.55,
1377) 					execResult[ 4 ]
1378) 				];
1379) 			}
1380) 		}, {

1381) 

1382) 			// this regex ignores A-F because it's compared against an already lowercased string
1383) 			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?/,
1384) 			parse: function( execResult ) {
1385) 				return [
1386) 					parseInt( execResult[ 1 ], 16 ),
1387) 					parseInt( execResult[ 2 ], 16 ),
1388) 					parseInt( execResult[ 3 ], 16 ),
1389) 					execResult[ 4 ] ?
1390) 						( parseInt( execResult[ 4 ], 16 ) / 255 ).toFixed( 2 ) :
1391) 						1
1392) 				];
1393) 			}
1394) 		}, {

1395) 

1396) 			// this regex ignores A-F because it's compared against an already lowercased string
1397) 			re: /#([a-f0-9])([a-f0-9])([a-f0-9])([a-f0-9])?/,
1398) 			parse: function( execResult ) {
1399) 				return [
1400) 					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
1401) 					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
1402) 					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ),
1403) 					execResult[ 4 ] ?
1404) 						( parseInt( execResult[ 4 ] + execResult[ 4 ], 16 ) / 255 )
1405) 							.toFixed( 2 ) :
1406) 						1
1407) 				];
1408) 			}
1409) 		}, {
1410) 			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1411) 			space: "hsla",
1412) 			parse: function( execResult ) {
1413) 				return [
1414) 					execResult[ 1 ],
1415) 					execResult[ 2 ] / 100,
1416) 					execResult[ 3 ] / 100,
1417) 					execResult[ 4 ]
1418) 				];
1419) 			}
1420) 		} ],

1421) 

1422) 	// jQuery.Color( )
1423) 	color = jQuery.Color = function( color, green, blue, alpha ) {
1424) 		return new jQuery.Color.fn.parse( color, green, blue, alpha );
1425) 	},
1426) 	spaces = {
1427) 		rgba: {
1428) 			props: {
1429) 				red: {
1430) 					idx: 0,
1431) 					type: "byte"
1432) 				},
1433) 				green: {
1434) 					idx: 1,
1435) 					type: "byte"
1436) 				},
1437) 				blue: {
1438) 					idx: 2,
1439) 					type: "byte"
1440) 				}
1441) 			}
1442) 		},

1443) 

1444) 		hsla: {
1445) 			props: {
1446) 				hue: {
1447) 					idx: 0,
1448) 					type: "degrees"
1449) 				},
1450) 				saturation: {
1451) 					idx: 1,
1452) 					type: "percent"
1453) 				},
1454) 				lightness: {
1455) 					idx: 2,
1456) 					type: "percent"
1457) 				}
1458) 			}

1459) 		}
1460) 	},

1461) 	propTypes = {
1462) 		"byte": {
1463) 			floor: true,
1464) 			max: 255
1465) 		},
1466) 		"percent": {
1467) 			max: 1
1468) 		},
1469) 		"degrees": {
1470) 			mod: 360,
1471) 			floor: true

1472) 		}
1473) 	},

1474) 	support = color.support = {},

1475) 

1476) 	// element for support tests
1477) 	supportElem = jQuery( "<p>" )[ 0 ],

1478) 

1479) 	// colors = jQuery.Color.names
1480) 	colors,

1481) 

1482) 	// local aliases of functions called often
1483) 	each = jQuery.each;

1484) 

1485) // determine rgba support immediately
1486) supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
1487) support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;

1488) 

1489) // define cache name and alpha properties
1490) // for rgba and hsla spaces
1491) each( spaces, function( spaceName, space ) {
1492) 	space.cache = "_" + spaceName;
1493) 	space.props.alpha = {
1494) 		idx: 3,
1495) 		type: "percent",
1496) 		def: 1
1497) 	};
1498) } );

1499) 

1500) // Populate the class2type map
1501) jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
1502) 	function( _i, name ) {
1503) 		class2type[ "[object " + name + "]" ] = name.toLowerCase();
1504) 	} );

1505) 

1506) function getType( obj ) {
1507) 	if ( obj == null ) {
1508) 		return obj + "";
1509) 	}

1510) 

1511) 	return typeof obj === "object" ?
1512) 		class2type[ toString.call( obj ) ] || "object" :
1513) 		typeof obj;
1514) }

1515) 

1516) function clamp( value, prop, allowEmpty ) {
1517) 	var type = propTypes[ prop.type ] || {};

1518) 

1519) 	if ( value == null ) {
1520) 		return ( allowEmpty || !prop.def ) ? null : prop.def;
1521) 	}

1522) 

1523) 	// ~~ is an short way of doing floor for positive numbers
1524) 	value = type.floor ? ~~value : parseFloat( value );

1525) 

1526) 	// IE will pass in empty strings as value for alpha,
1527) 	// which will hit this case
1528) 	if ( isNaN( value ) ) {
1529) 		return prop.def;
1530) 	}

1531) 

1532) 	if ( type.mod ) {

1533) 

1534) 		// we add mod before modding to make sure that negatives values
1535) 		// get converted properly: -10 -> 350
1536) 		return ( value + type.mod ) % type.mod;
1537) 	}

1538) 

1539) 	// for now all property types without mod have min and max
1540) 	return Math.min( type.max, Math.max( 0, value ) );
1541) }

1542) 

1543) function stringParse( string ) {
1544) 	var inst = color(),
1545) 		rgba = inst._rgba = [];

1546) 

1547) 	string = string.toLowerCase();

1548) 

1549) 	each( stringParsers, function( _i, parser ) {
1550) 		var parsed,
1551) 			match = parser.re.exec( string ),
1552) 			values = match && parser.parse( match ),
1553) 			spaceName = parser.space || "rgba";

1554) 

1555) 		if ( values ) {
1556) 			parsed = inst[ spaceName ]( values );

1557) 

1558) 			// if this was an rgba parse the assignment might happen twice
1559) 			// oh well....
1560) 			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
1561) 			rgba = inst._rgba = parsed._rgba;

1562) 

1563) 			// exit each( stringParsers ) here because we matched
1564) 			return false;

1565) 		}

1566) 	} );

1567) 

1568) 	// Found a stringParser that handled it
1569) 	if ( rgba.length ) {

1570) 

1571) 		// if this came from a parsed string, force "transparent" when alpha is 0
1572) 		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
1573) 		if ( rgba.join() === "0,0,0,0" ) {
1574) 			jQuery.extend( rgba, colors.transparent );
1575) 		}
1576) 		return inst;
1577) 	}

1578) 

1579) 	// named colors
1580) 	return colors[ string ];
1581) }

1582) 

1583) color.fn = jQuery.extend( color.prototype, {
1584) 	parse: function( red, green, blue, alpha ) {
1585) 		if ( red === undefined ) {
1586) 			this._rgba = [ null, null, null, null ];
1587) 			return this;
1588) 		}
1589) 		if ( red.jquery || red.nodeType ) {
1590) 			red = jQuery( red ).css( green );
1591) 			green = undefined;

1592) 		}
1593) 

1594) 		var inst = this,
1595) 			type = getType( red ),
1596) 			rgba = this._rgba = [];

1597) 

1598) 		// more than 1 argument specified - assume ( red, green, blue, alpha )
1599) 		if ( green !== undefined ) {
1600) 			red = [ red, green, blue, alpha ];
1601) 			type = "array";
1602) 		}

1603) 

1604) 		if ( type === "string" ) {
1605) 			return this.parse( stringParse( red ) || colors._default );
1606) 		}

1607) 

1608) 		if ( type === "array" ) {
1609) 			each( spaces.rgba.props, function( _key, prop ) {
1610) 				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
1611) 			} );
1612) 			return this;

1613) 		}
1614) 

1615) 		if ( type === "object" ) {
1616) 			if ( red instanceof color ) {
1617) 				each( spaces, function( _spaceName, space ) {
1618) 					if ( red[ space.cache ] ) {
1619) 						inst[ space.cache ] = red[ space.cache ].slice();
1620) 					}
1621) 				} );
1622) 			} else {
1623) 				each( spaces, function( _spaceName, space ) {
1624) 					var cache = space.cache;
1625) 					each( space.props, function( key, prop ) {

1626) 

1627) 						// if the cache doesn't exist, and we know how to convert
1628) 						if ( !inst[ cache ] && space.to ) {

1629) 

1630) 							// if the value was null, we don't need to copy it
1631) 							// if the key was alpha, we don't need to copy it either
1632) 							if ( key === "alpha" || red[ key ] == null ) {
1633) 								return;
1634) 							}
1635) 							inst[ cache ] = space.to( inst._rgba );
1636) 						}

1637) 

1638) 						// this is the only case where we allow nulls for ALL properties.
1639) 						// call clamp with alwaysAllowEmpty
1640) 						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
1641) 					} );

1642) 

1643) 					// everything defined but alpha?
1644) 					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
1645) 
1646) 						// use the default of 1
1647) 						if ( inst[ cache ][ 3 ] == null ) {
1648) 							inst[ cache ][ 3 ] = 1;
1649) 						}
1650) 
1651) 						if ( space.from ) {
1652) 							inst._rgba = space.from( inst[ cache ] );
1653) 						}
1654) 					}
1655) 				} );
1656) 			}
1657) 			return this;

1658) 		}
1659) 	},

1660) 	is: function( compare ) {
1661) 		var is = color( compare ),
1662) 			same = true,
1663) 			inst = this;

1664) 

1665) 		each( spaces, function( _, space ) {
1666) 			var localCache,
1667) 				isCache = is[ space.cache ];
1668) 			if ( isCache ) {
1669) 				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
1670) 				each( space.props, function( _, prop ) {
1671) 					if ( isCache[ prop.idx ] != null ) {
1672) 						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
1673) 						return same;
1674) 					}
1675) 				} );
1676) 			}
1677) 			return same;
1678) 		} );
1679) 		return same;
1680) 	},
1681) 	_space: function() {
1682) 		var used = [],
1683) 			inst = this;
1684) 		each( spaces, function( spaceName, space ) {
1685) 			if ( inst[ space.cache ] ) {
1686) 				used.push( spaceName );
1687) 			}
1688) 		} );
1689) 		return used.pop();
1690) 	},
1691) 	transition: function( other, distance ) {
1692) 		var end = color( other ),
1693) 			spaceName = end._space(),
1694) 			space = spaces[ spaceName ],
1695) 			startColor = this.alpha() === 0 ? color( "transparent" ) : this,
1696) 			start = startColor[ space.cache ] || space.to( startColor._rgba ),
1697) 			result = start.slice();

1698) 

1699) 		end = end[ space.cache ];
1700) 		each( space.props, function( _key, prop ) {
1701) 			var index = prop.idx,
1702) 				startValue = start[ index ],
1703) 				endValue = end[ index ],
1704) 				type = propTypes[ prop.type ] || {};

1705) 

1706) 			// if null, don't override start value
1707) 			if ( endValue === null ) {
1708) 				return;
1709) 			}

1710) 

1711) 			// if null - use end
1712) 			if ( startValue === null ) {
1713) 				result[ index ] = endValue;
1714) 			} else {
1715) 				if ( type.mod ) {
1716) 					if ( endValue - startValue > type.mod / 2 ) {
1717) 						startValue += type.mod;
1718) 					} else if ( startValue - endValue > type.mod / 2 ) {
1719) 						startValue -= type.mod;
1720) 					}
1721) 				}
1722) 				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
1723) 			}
1724) 		} );
1725) 		return this[ spaceName ]( result );
1726) 	},
1727) 	blend: function( opaque ) {
1728) 
1729) 		// if we are already opaque - return ourself
1730) 		if ( this._rgba[ 3 ] === 1 ) {
1731) 			return this;

1732) 		}
1733) 

1734) 		var rgb = this._rgba.slice(),
1735) 			a = rgb.pop(),
1736) 			blend = color( opaque )._rgba;
1737) 
1738) 		return color( jQuery.map( rgb, function( v, i ) {
1739) 			return ( 1 - a ) * blend[ i ] + a * v;
1740) 		} ) );

1741) 	},

1742) 	toRgbaString: function() {
1743) 		var prefix = "rgba(",
1744) 			rgba = jQuery.map( this._rgba, function( v, i ) {
1745) 				if ( v != null ) {
1746) 					return v;
1747) 				}
1748) 				return i > 2 ? 1 : 0;
1749) 			} );

1750) 

1751) 		if ( rgba[ 3 ] === 1 ) {
1752) 			rgba.pop();
1753) 			prefix = "rgb(";
1754) 		}
1755) 
1756) 		return prefix + rgba.join() + ")";
1757) 	},
1758) 	toHslaString: function() {
1759) 		var prefix = "hsla(",
1760) 			hsla = jQuery.map( this.hsla(), function( v, i ) {
1761) 				if ( v == null ) {
1762) 					v = i > 2 ? 1 : 0;
1763) 				}
1764) 
1765) 				// catch 1 and 2
1766) 				if ( i && i < 3 ) {
1767) 					v = Math.round( v * 100 ) + "%";
1768) 				}
1769) 				return v;
1770) 			} );
1771) 
1772) 		if ( hsla[ 3 ] === 1 ) {
1773) 			hsla.pop();
1774) 			prefix = "hsl(";
1775) 		}
1776) 		return prefix + hsla.join() + ")";
1777) 	},
1778) 	toHexString: function( includeAlpha ) {
1779) 		var rgba = this._rgba.slice(),
1780) 			alpha = rgba.pop();
1781) 
1782) 		if ( includeAlpha ) {
1783) 			rgba.push( ~~( alpha * 255 ) );
1784) 		}
1785) 
1786) 		return "#" + jQuery.map( rgba, function( v ) {
1787) 
1788) 			// default to 0 when nulls exist
1789) 			v = ( v || 0 ).toString( 16 );
1790) 			return v.length === 1 ? "0" + v : v;
1791) 		} ).join( "" );
1792) 	},
1793) 	toString: function() {
1794) 		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
1795) 	}
1796) } );
1797) color.fn.parse.prototype = color.fn;
1798) 
1799) // hsla conversions adapted from:
1800) // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
1801) 
1802) function hue2rgb( p, q, h ) {
1803) 	h = ( h + 1 ) % 1;
1804) 	if ( h * 6 < 1 ) {
1805) 		return p + ( q - p ) * h * 6;
1806) 	}
1807) 	if ( h * 2 < 1 ) {
1808) 		return q;
1809) 	}
1810) 	if ( h * 3 < 2 ) {
1811) 		return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
1812) 	}
1813) 	return p;
1814) }
1815) 
1816) spaces.hsla.to = function( rgba ) {
1817) 	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
1818) 		return [ null, null, null, rgba[ 3 ] ];
1819) 	}
1820) 	var r = rgba[ 0 ] / 255,
1821) 		g = rgba[ 1 ] / 255,
1822) 		b = rgba[ 2 ] / 255,
1823) 		a = rgba[ 3 ],
1824) 		max = Math.max( r, g, b ),
1825) 		min = Math.min( r, g, b ),
1826) 		diff = max - min,
1827) 		add = max + min,
1828) 		l = add * 0.5,
1829) 		h, s;
1830) 
1831) 	if ( min === max ) {
1832) 		h = 0;
1833) 	} else if ( r === max ) {
1834) 		h = ( 60 * ( g - b ) / diff ) + 360;
1835) 	} else if ( g === max ) {
1836) 		h = ( 60 * ( b - r ) / diff ) + 120;
1837) 	} else {
1838) 		h = ( 60 * ( r - g ) / diff ) + 240;
1839) 	}
1840) 
1841) 	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
1842) 	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
1843) 	if ( diff === 0 ) {
1844) 		s = 0;
1845) 	} else if ( l <= 0.5 ) {
1846) 		s = diff / add;
1847) 	} else {
1848) 		s = diff / ( 2 - add );
1849) 	}
1850) 	return [ Math.round( h ) % 360, s, l, a == null ? 1 : a ];
1851) };
1852) 
1853) spaces.hsla.from = function( hsla ) {
1854) 	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
1855) 		return [ null, null, null, hsla[ 3 ] ];
1856) 	}
1857) 	var h = hsla[ 0 ] / 360,
1858) 		s = hsla[ 1 ],
1859) 		l = hsla[ 2 ],
1860) 		a = hsla[ 3 ],
1861) 		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
1862) 		p = 2 * l - q;
1863) 
1864) 	return [
1865) 		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
1866) 		Math.round( hue2rgb( p, q, h ) * 255 ),
1867) 		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
1868) 		a
1869) 	];
1870) };
1871) 
1872) 
1873) each( spaces, function( spaceName, space ) {
1874) 	var props = space.props,
1875) 		cache = space.cache,
1876) 		to = space.to,
1877) 		from = space.from;
1878) 
1879) 	// makes rgba() and hsla()
1880) 	color.fn[ spaceName ] = function( value ) {
1881) 
1882) 		// generate a cache for this space if it doesn't exist
1883) 		if ( to && !this[ cache ] ) {
1884) 			this[ cache ] = to( this._rgba );
1885) 		}
1886) 		if ( value === undefined ) {
1887) 			return this[ cache ].slice();
1888) 		}
1889) 
1890) 		var ret,
1891) 			type = getType( value ),
1892) 			arr = ( type === "array" || type === "object" ) ? value : arguments,
1893) 			local = this[ cache ].slice();
1894) 
1895) 		each( props, function( key, prop ) {
1896) 			var val = arr[ type === "object" ? key : prop.idx ];
1897) 			if ( val == null ) {
1898) 				val = local[ prop.idx ];
1899) 			}
1900) 			local[ prop.idx ] = clamp( val, prop );
1901) 		} );
1902) 
1903) 		if ( from ) {
1904) 			ret = color( from( local ) );
1905) 			ret[ cache ] = local;
1906) 			return ret;
1907) 		} else {
1908) 			return color( local );
1909) 		}
1910) 	};
1911) 
1912) 	// makes red() green() blue() alpha() hue() saturation() lightness()
1913) 	each( props, function( key, prop ) {
1914) 
1915) 		// alpha is included in more than one space
1916) 		if ( color.fn[ key ] ) {
1917) 			return;
1918) 		}
1919) 		color.fn[ key ] = function( value ) {
1920) 			var local, cur, match, fn,
1921) 				vtype = getType( value );
1922) 
1923) 			if ( key === "alpha" ) {
1924) 				fn = this._hsla ? "hsla" : "rgba";
1925) 			} else {
1926) 				fn = spaceName;
1927) 			}
1928) 			local = this[ fn ]();
1929) 			cur = local[ prop.idx ];
1930) 
1931) 			if ( vtype === "undefined" ) {
1932) 				return cur;
1933) 			}
1934) 
1935) 			if ( vtype === "function" ) {
1936) 				value = value.call( this, cur );
1937) 				vtype = getType( value );
1938) 			}
1939) 			if ( value == null && prop.empty ) {
1940) 				return this;
1941) 			}
1942) 			if ( vtype === "string" ) {
1943) 				match = rplusequals.exec( value );
1944) 				if ( match ) {
1945) 					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
1946) 				}
1947) 			}
1948) 			local[ prop.idx ] = value;
1949) 			return this[ fn ]( local );
1950) 		};
1951) 	} );
1952) } );
1953) 
1954) // add cssHook and .fx.step function for each named hook.
1955) // accept a space separated string of properties
1956) color.hook = function( hook ) {
1957) 	var hooks = hook.split( " " );
1958) 	each( hooks, function( _i, hook ) {
1959) 		jQuery.cssHooks[ hook ] = {
1960) 			set: function( elem, value ) {
1961) 				var parsed, curElem,
1962) 					backgroundColor = "";
1963) 
1964) 				if ( value !== "transparent" && ( getType( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
1965) 					value = color( parsed || value );
1966) 					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
1967) 						curElem = hook === "backgroundColor" ? elem.parentNode : elem;
1968) 						while (
1969) 							( backgroundColor === "" || backgroundColor === "transparent" ) &&
1970) 							curElem && curElem.style
1971) 						) {
1972) 							try {
1973) 								backgroundColor = jQuery.css( curElem, "backgroundColor" );
1974) 								curElem = curElem.parentNode;
1975) 							} catch ( e ) {
1976) 							}
1977) 						}
1978) 
1979) 						value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
1980) 							backgroundColor :
1981) 							"_default" );
1982) 					}
1983) 
1984) 					value = value.toRgbaString();
1985) 				}
1986) 				try {
1987) 					elem.style[ hook ] = value;
1988) 				} catch ( e ) {
1989) 
1990) 					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
1991) 				}
1992) 			}
1993) 		};
1994) 		jQuery.fx.step[ hook ] = function( fx ) {
1995) 			if ( !fx.colorInit ) {
1996) 				fx.start = color( fx.elem, hook );
1997) 				fx.end = color( fx.end );
1998) 				fx.colorInit = true;
1999) 			}
2000) 			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
2001) 		};
2002) 	} );
2003) 
2004) };
2005) 
2006) color.hook( stepHooks );
2007) 
2008) jQuery.cssHooks.borderColor = {
2009) 	expand: function( value ) {
2010) 		var expanded = {};
2011) 
2012) 		each( [ "Top", "Right", "Bottom", "Left" ], function( _i, part ) {
2013) 			expanded[ "border" + part + "Color" ] = value;
2014) 		} );
2015) 		return expanded;
2016) 	}
2017) };
2018) 
2019) // Basic color names only.
2020) // Usage of any of the other color names requires adding yourself or including
2021) // jquery.color.svg-names.js.
2022) colors = jQuery.Color.names = {
2023) 
2024) 	// 4.1. Basic color keywords
2025) 	aqua: "#00ffff",
2026) 	black: "#000000",
2027) 	blue: "#0000ff",
2028) 	fuchsia: "#ff00ff",
2029) 	gray: "#808080",
2030) 	green: "#008000",
2031) 	lime: "#00ff00",
2032) 	maroon: "#800000",
2033) 	navy: "#000080",
2034) 	olive: "#808000",
2035) 	purple: "#800080",
2036) 	red: "#ff0000",
2037) 	silver: "#c0c0c0",
2038) 	teal: "#008080",
2039) 	white: "#ffffff",
2040) 	yellow: "#ffff00",
2041) 
2042) 	// 4.2.3. "transparent" color keyword
2043) 	transparent: [ null, null, null, 0 ],
2044) 
2045) 	_default: "#ffffff"
2046) };
2047) 
2048) 
2049) /*!
2050)  * jQuery UI Effects 1.13.2
2051)  * http://jqueryui.com
2052)  *
2053)  * Copyright jQuery Foundation and other contributors
2054)  * Released under the MIT license.
2055)  * http://jquery.org/license
2056)  */
2057) 
2058) //>>label: Effects Core
2059) //>>group: Effects
2060) /* eslint-disable max-len */
2061) //>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
2062) /* eslint-enable max-len */
2063) //>>docs: http://api.jqueryui.com/category/effects-core/
2064) //>>demos: http://jqueryui.com/effect/
2065) 
2066) 
2067) var dataSpace = "ui-effects-",
2068) 	dataSpaceStyle = "ui-effects-style",
2069) 	dataSpaceAnimated = "ui-effects-animated";
2070) 
2071) $.effects = {
2072) 	effect: {}
2073) };
2074) 
2075) /******************************************************************************/
2076) /****************************** CLASS ANIMATIONS ******************************/
2077) /******************************************************************************/
2078) ( function() {
2079) 
2080) var classAnimationActions = [ "add", "remove", "toggle" ],
2081) 	shorthandStyles = {
2082) 		border: 1,
2083) 		borderBottom: 1,
2084) 		borderColor: 1,
2085) 		borderLeft: 1,
2086) 		borderRight: 1,
2087) 		borderTop: 1,
2088) 		borderWidth: 1,
2089) 		margin: 1,
2090) 		padding: 1
2091) 	};
2092) 
2093) $.each(
2094) 	[ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ],
2095) 	function( _, prop ) {
2096) 		$.fx.step[ prop ] = function( fx ) {
2097) 			if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
2098) 				jQuery.style( fx.elem, prop, fx.end );
2099) 				fx.setAttr = true;
2100) 			}
2101) 		};
2102) 	}
2103) );
2104) 
2105) function camelCase( string ) {
2106) 	return string.replace( /-([\da-z])/gi, function( all, letter ) {
2107) 		return letter.toUpperCase();
2108) 	} );
2109) }
2110) 
2111) function getElementStyles( elem ) {
2112) 	var key, len,
2113) 		style = elem.ownerDocument.defaultView ?
2114) 			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
2115) 			elem.currentStyle,
2116) 		styles = {};
2117) 
2118) 	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
2119) 		len = style.length;
2120) 		while ( len-- ) {
2121) 			key = style[ len ];
2122) 			if ( typeof style[ key ] === "string" ) {
2123) 				styles[ camelCase( key ) ] = style[ key ];
2124) 			}
2125) 		}
2126) 
2127) 	// Support: Opera, IE <9
2128) 	} else {
2129) 		for ( key in style ) {
2130) 			if ( typeof style[ key ] === "string" ) {
2131) 				styles[ key ] = style[ key ];
2132) 			}
2133) 		}
2134) 	}
2135) 
2136) 	return styles;
2137) }
2138) 
2139) function styleDifference( oldStyle, newStyle ) {
2140) 	var diff = {},
2141) 		name, value;
2142) 
2143) 	for ( name in newStyle ) {
2144) 		value = newStyle[ name ];
2145) 		if ( oldStyle[ name ] !== value ) {
2146) 			if ( !shorthandStyles[ name ] ) {
2147) 				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
2148) 					diff[ name ] = value;
2149) 				}
2150) 			}
2151) 		}
2152) 	}
2153) 
2154) 	return diff;
2155) }
2156) 
2157) // Support: jQuery <1.8
2158) if ( !$.fn.addBack ) {
2159) 	$.fn.addBack = function( selector ) {
2160) 		return this.add( selector == null ?
2161) 			this.prevObject : this.prevObject.filter( selector )
2162) 		);
2163) 	};
2164) }
2165) 
2166) $.effects.animateClass = function( value, duration, easing, callback ) {
2167) 	var o = $.speed( duration, easing, callback );
2168) 
2169) 	return this.queue( function() {
2170) 		var animated = $( this ),
2171) 			baseClass = animated.attr( "class" ) || "",
2172) 			applyClassChange,
2173) 			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
2174) 
2175) 		// Map the animated objects to store the original styles.
2176) 		allAnimations = allAnimations.map( function() {
2177) 			var el = $( this );
2178) 			return {
2179) 				el: el,
2180) 				start: getElementStyles( this )
2181) 			};
2182) 		} );
2183) 
2184) 		// Apply class change
2185) 		applyClassChange = function() {
2186) 			$.each( classAnimationActions, function( i, action ) {
2187) 				if ( value[ action ] ) {
2188) 					animated[ action + "Class" ]( value[ action ] );
2189) 				}
2190) 			} );
2191) 		};
2192) 		applyClassChange();
2193) 
2194) 		// Map all animated objects again - calculate new styles and diff
2195) 		allAnimations = allAnimations.map( function() {
2196) 			this.end = getElementStyles( this.el[ 0 ] );
2197) 			this.diff = styleDifference( this.start, this.end );
2198) 			return this;
2199) 		} );
2200) 
2201) 		// Apply original class
2202) 		animated.attr( "class", baseClass );
2203) 
2204) 		// Map all animated objects again - this time collecting a promise
2205) 		allAnimations = allAnimations.map( function() {
2206) 			var styleInfo = this,
2207) 				dfd = $.Deferred(),
2208) 				opts = $.extend( {}, o, {
2209) 					queue: false,
2210) 					complete: function() {
2211) 						dfd.resolve( styleInfo );
2212) 					}
2213) 				} );
2214) 
2215) 			this.el.animate( this.diff, opts );
2216) 			return dfd.promise();
2217) 		} );
2218) 
2219) 		// Once all animations have completed:
2220) 		$.when.apply( $, allAnimations.get() ).done( function() {
2221) 
2222) 			// Set the final class
2223) 			applyClassChange();
2224) 
2225) 			// For each animated element,
2226) 			// clear all css properties that were animated
2227) 			$.each( arguments, function() {
2228) 				var el = this.el;
2229) 				$.each( this.diff, function( key ) {
2230) 					el.css( key, "" );
2231) 				} );
2232) 			} );
2233) 
2234) 			// This is guarnteed to be there if you use jQuery.speed()
2235) 			// it also handles dequeuing the next anim...
2236) 			o.complete.call( animated[ 0 ] );
2237) 		} );
2238) 	} );
2239) };
2240) 
2241) $.fn.extend( {
2242) 	addClass: ( function( orig ) {
2243) 		return function( classNames, speed, easing, callback ) {
2244) 			return speed ?
2245) 				$.effects.animateClass.call( this,
2246) 					{ add: classNames }, speed, easing, callback ) :
2247) 				orig.apply( this, arguments );
2248) 		};
2249) 	} )( $.fn.addClass ),
2250) 
2251) 	removeClass: ( function( orig ) {
2252) 		return function( classNames, speed, easing, callback ) {
2253) 			return arguments.length > 1 ?
2254) 				$.effects.animateClass.call( this,
2255) 					{ remove: classNames }, speed, easing, callback ) :
2256) 				orig.apply( this, arguments );
2257) 		};
2258) 	} )( $.fn.removeClass ),
2259) 
2260) 	toggleClass: ( function( orig ) {
2261) 		return function( classNames, force, speed, easing, callback ) {
2262) 			if ( typeof force === "boolean" || force === undefined ) {
2263) 				if ( !speed ) {
2264) 
2265) 					// Without speed parameter
2266) 					return orig.apply( this, arguments );
2267) 				} else {
2268) 					return $.effects.animateClass.call( this,
2269) 						( force ? { add: classNames } : { remove: classNames } ),
2270) 						speed, easing, callback );
2271) 				}
2272) 			} else {
2273) 
2274) 				// Without force parameter
2275) 				return $.effects.animateClass.call( this,
2276) 					{ toggle: classNames }, force, speed, easing );
2277) 			}
2278) 		};
2279) 	} )( $.fn.toggleClass ),
2280) 
2281) 	switchClass: function( remove, add, speed, easing, callback ) {
2282) 		return $.effects.animateClass.call( this, {
2283) 			add: add,
2284) 			remove: remove
2285) 		}, speed, easing, callback );
2286) 	}
2287) } );
2288) 
2289) } )();
2290) 
2291) /******************************************************************************/
2292) /*********************************** EFFECTS **********************************/
2293) /******************************************************************************/
2294) 
2295) ( function() {
2296) 
2297) if ( $.expr && $.expr.pseudos && $.expr.pseudos.animated ) {
2298) 	$.expr.pseudos.animated = ( function( orig ) {
2299) 		return function( elem ) {
2300) 			return !!$( elem ).data( dataSpaceAnimated ) || orig( elem );
2301) 		};
2302) 	} )( $.expr.pseudos.animated );
2303) }
2304) 
2305) if ( $.uiBackCompat !== false ) {
2306) 	$.extend( $.effects, {
2307) 
2308) 		// Saves a set of properties in a data storage
2309) 		save: function( element, set ) {
2310) 			var i = 0, length = set.length;
2311) 			for ( ; i < length; i++ ) {
2312) 				if ( set[ i ] !== null ) {
2313) 					element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
2314) 				}
2315) 			}
2316) 		},
2317) 
2318) 		// Restores a set of previously saved properties from a data storage
2319) 		restore: function( element, set ) {
2320) 			var val, i = 0, length = set.length;
2321) 			for ( ; i < length; i++ ) {
2322) 				if ( set[ i ] !== null ) {
2323) 					val = element.data( dataSpace + set[ i ] );
2324) 					element.css( set[ i ], val );
2325) 				}
2326) 			}
2327) 		},
2328) 
2329) 		setMode: function( el, mode ) {
2330) 			if ( mode === "toggle" ) {
2331) 				mode = el.is( ":hidden" ) ? "show" : "hide";
2332) 			}
2333) 			return mode;
2334) 		},
2335) 
2336) 		// Wraps the element around a wrapper that copies position properties
2337) 		createWrapper: function( element ) {
2338) 
2339) 			// If the element is already wrapped, return it
2340) 			if ( element.parent().is( ".ui-effects-wrapper" ) ) {
2341) 				return element.parent();
2342) 			}
2343) 
2344) 			// Wrap the element
2345) 			var props = {
2346) 					width: element.outerWidth( true ),
2347) 					height: element.outerHeight( true ),
2348) 					"float": element.css( "float" )
2349) 				},
2350) 				wrapper = $( "<div></div>" )
2351) 					.addClass( "ui-effects-wrapper" )
2352) 					.css( {
2353) 						fontSize: "100%",
2354) 						background: "transparent",
2355) 						border: "none",
2356) 						margin: 0,
2357) 						padding: 0
2358) 					} ),
2359) 
2360) 				// Store the size in case width/height are defined in % - Fixes #5245
2361) 				size = {
2362) 					width: element.width(),
2363) 					height: element.height()
2364) 				},
2365) 				active = document.activeElement;
2366) 
2367) 			// Support: Firefox
2368) 			// Firefox incorrectly exposes anonymous content
2369) 			// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
2370) 			try {
2371) 				// eslint-disable-next-line no-unused-expressions
2372) 				active.id;
2373) 			} catch ( e ) {
2374) 				active = document.body;
2375) 			}
2376) 
2377) 			element.wrap( wrapper );
2378) 
2379) 			// Fixes #7595 - Elements lose focus when wrapped.
2380) 			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2381) 				$( active ).trigger( "focus" );
2382) 			}
2383) 
2384) 			// Hotfix for jQuery 1.4 since some change in wrap() seems to actually
2385) 			// lose the reference to the wrapped element
2386) 			wrapper = element.parent();
2387) 
2388) 			// Transfer positioning properties to the wrapper
2389) 			if ( element.css( "position" ) === "static" ) {
2390) 				wrapper.css( { position: "relative" } );
2391) 				element.css( { position: "relative" } );
2392) 			} else {
2393) 				$.extend( props, {
2394) 					position: element.css( "position" ),
2395) 					zIndex: element.css( "z-index" )
2396) 				} );
2397) 				$.each( [ "top", "left", "bottom", "right" ], function( i, pos ) {
2398) 					props[ pos ] = element.css( pos );
2399) 					if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
2400) 						props[ pos ] = "auto";
2401) 					}
2402) 				} );
2403) 				element.css( {
2404) 					position: "relative",
2405) 					top: 0,
2406) 					left: 0,
2407) 					right: "auto",
2408) 					bottom: "auto"
2409) 				} );
2410) 			}
2411) 			element.css( size );
2412) 
2413) 			return wrapper.css( props ).show();
2414) 		},
2415) 
2416) 		removeWrapper: function( element ) {
2417) 			var active = document.activeElement;
2418) 
2419) 			if ( element.parent().is( ".ui-effects-wrapper" ) ) {
2420) 				element.parent().replaceWith( element );
2421) 
2422) 				// Fixes #7595 - Elements lose focus when wrapped.
2423) 				if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2424) 					$( active ).trigger( "focus" );
2425) 				}
2426) 			}
2427) 
2428) 			return element;
2429) 		}
2430) 	} );
2431) }
2432) 
2433) $.extend( $.effects, {
2434) 	version: "1.13.2",
2435) 
2436) 	define: function( name, mode, effect ) {
2437) 		if ( !effect ) {
2438) 			effect = mode;
2439) 			mode = "effect";
2440) 		}
2441) 
2442) 		$.effects.effect[ name ] = effect;
2443) 		$.effects.effect[ name ].mode = mode;
2444) 
2445) 		return effect;
2446) 	},
2447) 
2448) 	scaledDimensions: function( element, percent, direction ) {
2449) 		if ( percent === 0 ) {
2450) 			return {
2451) 				height: 0,
2452) 				width: 0,
2453) 				outerHeight: 0,
2454) 				outerWidth: 0
2455) 			};
2456) 		}
2457) 
2458) 		var x = direction !== "horizontal" ? ( ( percent || 100 ) / 100 ) : 1,
2459) 			y = direction !== "vertical" ? ( ( percent || 100 ) / 100 ) : 1;
2460) 
2461) 		return {
2462) 			height: element.height() * y,
2463) 			width: element.width() * x,
2464) 			outerHeight: element.outerHeight() * y,
2465) 			outerWidth: element.outerWidth() * x
2466) 		};
2467) 
2468) 	},
2469) 
2470) 	clipToBox: function( animation ) {
2471) 		return {
2472) 			width: animation.clip.right - animation.clip.left,
2473) 			height: animation.clip.bottom - animation.clip.top,
2474) 			left: animation.clip.left,
2475) 			top: animation.clip.top
2476) 		};
2477) 	},
2478) 
2479) 	// Injects recently queued functions to be first in line (after "inprogress")
2480) 	unshift: function( element, queueLength, count ) {
2481) 		var queue = element.queue();
2482) 
2483) 		if ( queueLength > 1 ) {
2484) 			queue.splice.apply( queue,
2485) 				[ 1, 0 ].concat( queue.splice( queueLength, count ) ) );
2486) 		}
2487) 		element.dequeue();
2488) 	},
2489) 
2490) 	saveStyle: function( element ) {
2491) 		element.data( dataSpaceStyle, element[ 0 ].style.cssText );
2492) 	},
2493) 
2494) 	restoreStyle: function( element ) {
2495) 		element[ 0 ].style.cssText = element.data( dataSpaceStyle ) || "";
2496) 		element.removeData( dataSpaceStyle );
2497) 	},
2498) 
2499) 	mode: function( element, mode ) {
2500) 		var hidden = element.is( ":hidden" );
2501) 
2502) 		if ( mode === "toggle" ) {
2503) 			mode = hidden ? "show" : "hide";
2504) 		}
2505) 		if ( hidden ? mode === "hide" : mode === "show" ) {
2506) 			mode = "none";
2507) 		}
2508) 		return mode;
2509) 	},
2510) 
2511) 	// Translates a [top,left] array into a baseline value
2512) 	getBaseline: function( origin, original ) {
2513) 		var y, x;
2514) 
2515) 		switch ( origin[ 0 ] ) {
2516) 		case "top":
2517) 			y = 0;
2518) 			break;
2519) 		case "middle":
2520) 			y = 0.5;
2521) 			break;
2522) 		case "bottom":
2523) 			y = 1;
2524) 			break;
2525) 		default:
2526) 			y = origin[ 0 ] / original.height;
2527) 		}
2528) 
2529) 		switch ( origin[ 1 ] ) {
2530) 		case "left":
2531) 			x = 0;
2532) 			break;
2533) 		case "center":
2534) 			x = 0.5;
2535) 			break;
2536) 		case "right":
2537) 			x = 1;
2538) 			break;
2539) 		default:
2540) 			x = origin[ 1 ] / original.width;
2541) 		}
2542) 
2543) 		return {
2544) 			x: x,
2545) 			y: y
2546) 		};
2547) 	},
2548) 
2549) 	// Creates a placeholder element so that the original element can be made absolute
2550) 	createPlaceholder: function( element ) {
2551) 		var placeholder,
2552) 			cssPosition = element.css( "position" ),
2553) 			position = element.position();
2554) 
2555) 		// Lock in margins first to account for form elements, which
2556) 		// will change margin if you explicitly set height
2557) 		// see: http://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380
2558) 		// Support: Safari
2559) 		element.css( {
2560) 			marginTop: element.css( "marginTop" ),
2561) 			marginBottom: element.css( "marginBottom" ),
2562) 			marginLeft: element.css( "marginLeft" ),
2563) 			marginRight: element.css( "marginRight" )
2564) 		} )
2565) 		.outerWidth( element.outerWidth() )
2566) 		.outerHeight( element.outerHeight() );
2567) 
2568) 		if ( /^(static|relative)/.test( cssPosition ) ) {
2569) 			cssPosition = "absolute";
2570) 
2571) 			placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( {
2572) 
2573) 				// Convert inline to inline block to account for inline elements
2574) 				// that turn to inline block based on content (like img)
2575) 				display: /^(inline|ruby)/.test( element.css( "display" ) ) ?
2576) 					"inline-block" :
2577) 					"block",
2578) 				visibility: "hidden",
2579) 
2580) 				// Margins need to be set to account for margin collapse
2581) 				marginTop: element.css( "marginTop" ),
2582) 				marginBottom: element.css( "marginBottom" ),
2583) 				marginLeft: element.css( "marginLeft" ),
2584) 				marginRight: element.css( "marginRight" ),
2585) 				"float": element.css( "float" )
2586) 			} )
2587) 			.outerWidth( element.outerWidth() )
2588) 			.outerHeight( element.outerHeight() )
2589) 			.addClass( "ui-effects-placeholder" );
2590) 
2591) 			element.data( dataSpace + "placeholder", placeholder );
2592) 		}
2593) 
2594) 		element.css( {
2595) 			position: cssPosition,
2596) 			left: position.left,
2597) 			top: position.top
2598) 		} );
2599) 
2600) 		return placeholder;
2601) 	},
2602) 
2603) 	removePlaceholder: function( element ) {
2604) 		var dataKey = dataSpace + "placeholder",
2605) 				placeholder = element.data( dataKey );
2606) 
2607) 		if ( placeholder ) {
2608) 			placeholder.remove();
2609) 			element.removeData( dataKey );
2610) 		}
2611) 	},
2612) 
2613) 	// Removes a placeholder if it exists and restores
2614) 	// properties that were modified during placeholder creation
2615) 	cleanUp: function( element ) {
2616) 		$.effects.restoreStyle( element );
2617) 		$.effects.removePlaceholder( element );
2618) 	},
2619) 
2620) 	setTransition: function( element, list, factor, value ) {
2621) 		value = value || {};
2622) 		$.each( list, function( i, x ) {
2623) 			var unit = element.cssUnit( x );
2624) 			if ( unit[ 0 ] > 0 ) {
2625) 				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
2626) 			}
2627) 		} );
2628) 		return value;
2629) 	}
2630) } );
2631) 
2632) // Return an effect options object for the given parameters:
2633) function _normalizeArguments( effect, options, speed, callback ) {
2634) 
2635) 	// Allow passing all options as the first parameter
2636) 	if ( $.isPlainObject( effect ) ) {
2637) 		options = effect;
2638) 		effect = effect.effect;
2639) 	}
2640) 
2641) 	// Convert to an object
2642) 	effect = { effect: effect };
2643) 
2644) 	// Catch (effect, null, ...)
2645) 	if ( options == null ) {
2646) 		options = {};
2647) 	}
2648) 
2649) 	// Catch (effect, callback)
2650) 	if ( typeof options === "function" ) {
2651) 		callback = options;
2652) 		speed = null;
2653) 		options = {};
2654) 	}
2655) 
2656) 	// Catch (effect, speed, ?)
2657) 	if ( typeof options === "number" || $.fx.speeds[ options ] ) {
2658) 		callback = speed;
2659) 		speed = options;
2660) 		options = {};
2661) 	}
2662) 
2663) 	// Catch (effect, options, callback)
2664) 	if ( typeof speed === "function" ) {
2665) 		callback = speed;
2666) 		speed = null;
2667) 	}
2668) 
2669) 	// Add options to effect
2670) 	if ( options ) {
2671) 		$.extend( effect, options );
2672) 	}
2673) 
2674) 	speed = speed || options.duration;
2675) 	effect.duration = $.fx.off ? 0 :
2676) 		typeof speed === "number" ? speed :
2677) 		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
2678) 		$.fx.speeds._default;
2679) 
2680) 	effect.complete = callback || options.complete;
2681) 
2682) 	return effect;
2683) }
2684) 
2685) function standardAnimationOption( option ) {
2686) 
2687) 	// Valid standard speeds (nothing, number, named speed)
2688) 	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
2689) 		return true;
2690) 	}
2691) 
2692) 	// Invalid strings - treat as "normal" speed
2693) 	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
2694) 		return true;
2695) 	}
2696) 
2697) 	// Complete callback
2698) 	if ( typeof option === "function" ) {
2699) 		return true;
2700) 	}
2701) 
2702) 	// Options hash (but not naming an effect)
2703) 	if ( typeof option === "object" && !option.effect ) {
2704) 		return true;
2705) 	}
2706) 
2707) 	// Didn't match any standard API
2708) 	return false;
2709) }
2710) 
2711) $.fn.extend( {
2712) 	effect: function( /* effect, options, speed, callback */ ) {
2713) 		var args = _normalizeArguments.apply( this, arguments ),
2714) 			effectMethod = $.effects.effect[ args.effect ],
2715) 			defaultMode = effectMethod.mode,
2716) 			queue = args.queue,
2717) 			queueName = queue || "fx",
2718) 			complete = args.complete,
2719) 			mode = args.mode,
2720) 			modes = [],
2721) 			prefilter = function( next ) {
2722) 				var el = $( this ),
2723) 					normalizedMode = $.effects.mode( el, mode ) || defaultMode;
2724) 
2725) 				// Sentinel for duck-punching the :animated pseudo-selector
2726) 				el.data( dataSpaceAnimated, true );
2727) 
2728) 				// Save effect mode for later use,
2729) 				// we can't just call $.effects.mode again later,
2730) 				// as the .show() below destroys the initial state
2731) 				modes.push( normalizedMode );
2732) 
2733) 				// See $.uiBackCompat inside of run() for removal of defaultMode in 1.14
2734) 				if ( defaultMode && ( normalizedMode === "show" ||
2735) 						( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) {
2736) 					el.show();
2737) 				}
2738) 
2739) 				if ( !defaultMode || normalizedMode !== "none" ) {
2740) 					$.effects.saveStyle( el );
2741) 				}
2742) 
2743) 				if ( typeof next === "function" ) {
2744) 					next();
2745) 				}

2746) 			};
2747) 

2748) 		if ( $.fx.off || !effectMethod ) {
2749) 
2750) 			// Delegate to the original method (e.g., .show()) if possible
2751) 			if ( mode ) {
2752) 				return this[ mode ]( args.duration, complete );
2753) 			} else {
2754) 				return this.each( function() {
2755) 					if ( complete ) {
2756) 						complete.call( this );
2757) 					}
2758) 				} );
2759) 			}
2760) 		}
2761) 
2762) 		function run( next ) {
2763) 			var elem = $( this );
2764) 
2765) 			function cleanup() {
2766) 				elem.removeData( dataSpaceAnimated );
2767) 
2768) 				$.effects.cleanUp( elem );
2769) 
2770) 				if ( args.mode === "hide" ) {
2771) 					elem.hide();
2772) 				}
2773) 
2774) 				done();
2775) 			}
2776) 
2777) 			function done() {
2778) 				if ( typeof complete === "function" ) {
2779) 					complete.call( elem[ 0 ] );
2780) 				}
2781) 
2782) 				if ( typeof next === "function" ) {
2783) 					next();
2784) 				}
2785) 			}
2786) 
2787) 			// Override mode option on a per element basis,
2788) 			// as toggle can be either show or hide depending on element state
2789) 			args.mode = modes.shift();
2790) 
2791) 			if ( $.uiBackCompat !== false && !defaultMode ) {
2792) 				if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
2793) 
2794) 					// Call the core method to track "olddisplay" properly
2795) 					elem[ mode ]();
2796) 					done();
2797) 				} else {
2798) 					effectMethod.call( elem[ 0 ], args, done );
2799) 				}
2800) 			} else {
2801) 				if ( args.mode === "none" ) {
2802) 
2803) 					// Call the core method to track "olddisplay" properly
2804) 					elem[ mode ]();
2805) 					done();
2806) 				} else {
2807) 					effectMethod.call( elem[ 0 ], args, cleanup );
2808) 				}
2809) 			}
2810) 		}
2811) 
2812) 		// Run prefilter on all elements first to ensure that
2813) 		// any showing or hiding happens before placeholder creation,
2814) 		// which ensures that any layout changes are correctly captured.
2815) 		return queue === false ?
2816) 			this.each( prefilter ).each( run ) :
2817) 			this.queue( queueName, prefilter ).queue( queueName, run );
2818) 	},
2819) 
2820) 	show: ( function( orig ) {
2821) 		return function( option ) {
2822) 			if ( standardAnimationOption( option ) ) {
2823) 				return orig.apply( this, arguments );
2824) 			} else {
2825) 				var args = _normalizeArguments.apply( this, arguments );
2826) 				args.mode = "show";
2827) 				return this.effect.call( this, args );
2828) 			}
2829) 		};
2830) 	} )( $.fn.show ),
2831) 
2832) 	hide: ( function( orig ) {
2833) 		return function( option ) {
2834) 			if ( standardAnimationOption( option ) ) {
2835) 				return orig.apply( this, arguments );
2836) 			} else {
2837) 				var args = _normalizeArguments.apply( this, arguments );
2838) 				args.mode = "hide";
2839) 				return this.effect.call( this, args );
2840) 			}
2841) 		};
2842) 	} )( $.fn.hide ),
2843) 
2844) 	toggle: ( function( orig ) {
2845) 		return function( option ) {
2846) 			if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
2847) 				return orig.apply( this, arguments );
2848) 			} else {
2849) 				var args = _normalizeArguments.apply( this, arguments );
2850) 				args.mode = "toggle";
2851) 				return this.effect.call( this, args );
2852) 			}
2853) 		};
2854) 	} )( $.fn.toggle ),
2855) 
2856) 	cssUnit: function( key ) {
2857) 		var style = this.css( key ),
2858) 			val = [];
2859) 
2860) 		$.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
2861) 			if ( style.indexOf( unit ) > 0 ) {
2862) 				val = [ parseFloat( style ), unit ];
2863) 			}
2864) 		} );
2865) 		return val;
2866) 	},
2867) 
2868) 	cssClip: function( clipObj ) {
2869) 		if ( clipObj ) {
2870) 			return this.css( "clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " +
2871) 				clipObj.bottom + "px " + clipObj.left + "px)" );
2872) 		}
2873) 		return parseClip( this.css( "clip" ), this );
2874) 	},
2875) 
2876) 	transfer: function( options, done ) {
2877) 		var element = $( this ),
2878) 			target = $( options.to ),
2879) 			targetFixed = target.css( "position" ) === "fixed",
2880) 			body = $( "body" ),
2881) 			fixTop = targetFixed ? body.scrollTop() : 0,
2882) 			fixLeft = targetFixed ? body.scrollLeft() : 0,
2883) 			endPosition = target.offset(),
2884) 			animation = {
2885) 				top: endPosition.top - fixTop,
2886) 				left: endPosition.left - fixLeft,
2887) 				height: target.innerHeight(),
2888) 				width: target.innerWidth()
2889) 			},
2890) 			startPosition = element.offset(),
2891) 			transfer = $( "<div class='ui-effects-transfer'></div>" );
2892) 
2893) 		transfer
2894) 			.appendTo( "body" )
2895) 			.addClass( options.className )
2896) 			.css( {
2897) 				top: startPosition.top - fixTop,
2898) 				left: startPosition.left - fixLeft,
2899) 				height: element.innerHeight(),
2900) 				width: element.innerWidth(),
2901) 				position: targetFixed ? "fixed" : "absolute"
2902) 			} )
2903) 			.animate( animation, options.duration, options.easing, function() {
2904) 				transfer.remove();
2905) 				if ( typeof done === "function" ) {
2906) 					done();
2907) 				}
2908) 			} );
2909) 	}
2910) } );
2911) 
2912) function parseClip( str, element ) {
2913) 		var outerWidth = element.outerWidth(),
2914) 			outerHeight = element.outerHeight(),
2915) 			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)\)$/,
2916) 			values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ];
2917) 
2918) 		return {
2919) 			top: parseFloat( values[ 1 ] ) || 0,
2920) 			right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ),
2921) 			bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ),
2922) 			left: parseFloat( values[ 4 ] ) || 0
2923) 		};
2924) }
2925) 
2926) $.fx.step.clip = function( fx ) {
2927) 	if ( !fx.clipInit ) {
2928) 		fx.start = $( fx.elem ).cssClip();
2929) 		if ( typeof fx.end === "string" ) {
2930) 			fx.end = parseClip( fx.end, fx.elem );
2931) 		}
2932) 		fx.clipInit = true;
2933) 	}
2934) 
2935) 	$( fx.elem ).cssClip( {
2936) 		top: fx.pos * ( fx.end.top - fx.start.top ) + fx.start.top,
2937) 		right: fx.pos * ( fx.end.right - fx.start.right ) + fx.start.right,
2938) 		bottom: fx.pos * ( fx.end.bottom - fx.start.bottom ) + fx.start.bottom,
2939) 		left: fx.pos * ( fx.end.left - fx.start.left ) + fx.start.left
2940) 	} );
2941) };
2942) 
2943) } )();
2944) 
2945) /******************************************************************************/
2946) /*********************************** EASING ***********************************/
2947) /******************************************************************************/
2948) 
2949) ( function() {
2950) 
2951) // Based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
2952) 
2953) var baseEasings = {};
2954) 
2955) $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
2956) 	baseEasings[ name ] = function( p ) {
2957) 		return Math.pow( p, i + 2 );
2958) 	};
2959) } );
2960) 
2961) $.extend( baseEasings, {
2962) 	Sine: function( p ) {
2963) 		return 1 - Math.cos( p * Math.PI / 2 );
2964) 	},
2965) 	Circ: function( p ) {
2966) 		return 1 - Math.sqrt( 1 - p * p );
2967) 	},
2968) 	Elastic: function( p ) {
2969) 		return p === 0 || p === 1 ? p :
2970) 			-Math.pow( 2, 8 * ( p - 1 ) ) * Math.sin( ( ( p - 1 ) * 80 - 7.5 ) * Math.PI / 15 );
2971) 	},
2972) 	Back: function( p ) {
2973) 		return p * p * ( 3 * p - 2 );
2974) 	},
2975) 	Bounce: function( p ) {
2976) 		var pow2,
2977) 			bounce = 4;
2978) 
2979) 		while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
2980) 		return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
2981) 	}
2982) } );
2983) 
2984) $.each( baseEasings, function( name, easeIn ) {
2985) 	$.easing[ "easeIn" + name ] = easeIn;
2986) 	$.easing[ "easeOut" + name ] = function( p ) {
2987) 		return 1 - easeIn( 1 - p );
2988) 	};
2989) 	$.easing[ "easeInOut" + name ] = function( p ) {
2990) 		return p < 0.5 ?
2991) 			easeIn( p * 2 ) / 2 :
2992) 			1 - easeIn( p * -2 + 2 ) / 2;
2993) 	};
2994) } );
2995) 
2996) } )();
2997) 
2998) var effect = $.effects;
2999) 
3000) 
3001) /*!
3002)  * jQuery UI Effects Blind 1.13.2
3003)  * http://jqueryui.com
3004)  *
3005)  * Copyright jQuery Foundation and other contributors
3006)  * Released under the MIT license.
3007)  * http://jquery.org/license
3008)  */
3009) 
3010) //>>label: Blind Effect
3011) //>>group: Effects
3012) //>>description: Blinds the element.
3013) //>>docs: http://api.jqueryui.com/blind-effect/
3014) //>>demos: http://jqueryui.com/effect/
3015) 
3016) 
3017) var effectsEffectBlind = $.effects.define( "blind", "hide", function( options, done ) {
3018) 	var map = {
3019) 			up: [ "bottom", "top" ],
3020) 			vertical: [ "bottom", "top" ],
3021) 			down: [ "top", "bottom" ],
3022) 			left: [ "right", "left" ],
3023) 			horizontal: [ "right", "left" ],
3024) 			right: [ "left", "right" ]
3025) 		},
3026) 		element = $( this ),
3027) 		direction = options.direction || "up",
3028) 		start = element.cssClip(),
3029) 		animate = { clip: $.extend( {}, start ) },
3030) 		placeholder = $.effects.createPlaceholder( element );
3031) 
3032) 	animate.clip[ map[ direction ][ 0 ] ] = animate.clip[ map[ direction ][ 1 ] ];
3033) 
3034) 	if ( options.mode === "show" ) {
3035) 		element.cssClip( animate.clip );
3036) 		if ( placeholder ) {
3037) 			placeholder.css( $.effects.clipToBox( animate ) );
3038) 		}
3039) 
3040) 		animate.clip = start;
3041) 	}
3042) 
3043) 	if ( placeholder ) {
3044) 		placeholder.animate( $.effects.clipToBox( animate ), options.duration, options.easing );
3045) 	}
3046) 
3047) 	element.animate( animate, {
3048) 		queue: false,
3049) 		duration: options.duration,
3050) 		easing: options.easing,
3051) 		complete: done
3052) 	} );
3053) } );
3054) 
3055) 
3056) /*!
3057)  * jQuery UI Effects Bounce 1.13.2
3058)  * http://jqueryui.com
3059)  *
3060)  * Copyright jQuery Foundation and other contributors
3061)  * Released under the MIT license.
3062)  * http://jquery.org/license
3063)  */
3064) 
3065) //>>label: Bounce Effect
3066) //>>group: Effects
3067) //>>description: Bounces an element horizontally or vertically n times.
3068) //>>docs: http://api.jqueryui.com/bounce-effect/
3069) //>>demos: http://jqueryui.com/effect/
3070) 
3071) 
3072) var effectsEffectBounce = $.effects.define( "bounce", function( options, done ) {
3073) 	var upAnim, downAnim, refValue,
3074) 		element = $( this ),
3075) 
3076) 		// Defaults:
3077) 		mode = options.mode,
3078) 		hide = mode === "hide",
3079) 		show = mode === "show",
3080) 		direction = options.direction || "up",
3081) 		distance = options.distance,
3082) 		times = options.times || 5,
3083) 
3084) 		// Number of internal animations
3085) 		anims = times * 2 + ( show || hide ? 1 : 0 ),
3086) 		speed = options.duration / anims,
3087) 		easing = options.easing,
3088) 
3089) 		// Utility:
3090) 		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3091) 		motion = ( direction === "up" || direction === "left" ),
3092) 		i = 0,
3093) 
3094) 		queuelen = element.queue().length;
3095) 
3096) 	$.effects.createPlaceholder( element );
3097) 
3098) 	refValue = element.css( ref );
3099) 
3100) 	// Default distance for the BIGGEST bounce is the outer Distance / 3
3101) 	if ( !distance ) {
3102) 		distance = element[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
3103) 	}
3104) 
3105) 	if ( show ) {
3106) 		downAnim = { opacity: 1 };
3107) 		downAnim[ ref ] = refValue;
3108) 
3109) 		// If we are showing, force opacity 0 and set the initial position
3110) 		// then do the "first" animation
3111) 		element
3112) 			.css( "opacity", 0 )
3113) 			.css( ref, motion ? -distance * 2 : distance * 2 )
3114) 			.animate( downAnim, speed, easing );
3115) 	}
3116) 
3117) 	// Start at the smallest distance if we are hiding
3118) 	if ( hide ) {
3119) 		distance = distance / Math.pow( 2, times - 1 );
3120) 	}
3121) 
3122) 	downAnim = {};
3123) 	downAnim[ ref ] = refValue;
3124) 
3125) 	// Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
3126) 	for ( ; i < times; i++ ) {
3127) 		upAnim = {};
3128) 		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
3129) 
3130) 		element
3131) 			.animate( upAnim, speed, easing )
3132) 			.animate( downAnim, speed, easing );
3133) 
3134) 		distance = hide ? distance * 2 : distance / 2;
3135) 	}
3136) 
3137) 	// Last Bounce when Hiding
3138) 	if ( hide ) {
3139) 		upAnim = { opacity: 0 };
3140) 		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
3141) 
3142) 		element.animate( upAnim, speed, easing );
3143) 	}
3144) 
3145) 	element.queue( done );
3146) 
3147) 	$.effects.unshift( element, queuelen, anims + 1 );
3148) } );
3149) 
3150) 
3151) /*!
3152)  * jQuery UI Effects Clip 1.13.2
3153)  * http://jqueryui.com
3154)  *
3155)  * Copyright jQuery Foundation and other contributors
3156)  * Released under the MIT license.
3157)  * http://jquery.org/license
3158)  */
3159) 
3160) //>>label: Clip Effect
3161) //>>group: Effects
3162) //>>description: Clips the element on and off like an old TV.
3163) //>>docs: http://api.jqueryui.com/clip-effect/
3164) //>>demos: http://jqueryui.com/effect/
3165) 
3166) 
3167) var effectsEffectClip = $.effects.define( "clip", "hide", function( options, done ) {
3168) 	var start,
3169) 		animate = {},
3170) 		element = $( this ),
3171) 		direction = options.direction || "vertical",
3172) 		both = direction === "both",
3173) 		horizontal = both || direction === "horizontal",
3174) 		vertical = both || direction === "vertical";
3175) 
3176) 	start = element.cssClip();
3177) 	animate.clip = {
3178) 		top: vertical ? ( start.bottom - start.top ) / 2 : start.top,
3179) 		right: horizontal ? ( start.right - start.left ) / 2 : start.right,
3180) 		bottom: vertical ? ( start.bottom - start.top ) / 2 : start.bottom,
3181) 		left: horizontal ? ( start.right - start.left ) / 2 : start.left
3182) 	};
3183) 
3184) 	$.effects.createPlaceholder( element );
3185) 
3186) 	if ( options.mode === "show" ) {
3187) 		element.cssClip( animate.clip );
3188) 		animate.clip = start;
3189) 	}
3190) 
3191) 	element.animate( animate, {
3192) 		queue: false,
3193) 		duration: options.duration,
3194) 		easing: options.easing,
3195) 		complete: done
3196) 	} );
3197) 
3198) } );
3199) 
3200) 
3201) /*!
3202)  * jQuery UI Effects Drop 1.13.2
3203)  * http://jqueryui.com
3204)  *
3205)  * Copyright jQuery Foundation and other contributors
3206)  * Released under the MIT license.
3207)  * http://jquery.org/license
3208)  */
3209) 
3210) //>>label: Drop Effect
3211) //>>group: Effects
3212) //>>description: Moves an element in one direction and hides it at the same time.
3213) //>>docs: http://api.jqueryui.com/drop-effect/
3214) //>>demos: http://jqueryui.com/effect/
3215) 
3216) 
3217) var effectsEffectDrop = $.effects.define( "drop", "hide", function( options, done ) {
3218) 
3219) 	var distance,
3220) 		element = $( this ),
3221) 		mode = options.mode,
3222) 		show = mode === "show",
3223) 		direction = options.direction || "left",
3224) 		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3225) 		motion = ( direction === "up" || direction === "left" ) ? "-=" : "+=",
3226) 		oppositeMotion = ( motion === "+=" ) ? "-=" : "+=",
3227) 		animation = {
3228) 			opacity: 0
3229) 		};
3230) 
3231) 	$.effects.createPlaceholder( element );
3232) 
3233) 	distance = options.distance ||
3234) 		element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
3235) 
3236) 	animation[ ref ] = motion + distance;
3237) 
3238) 	if ( show ) {
3239) 		element.css( animation );
3240) 
3241) 		animation[ ref ] = oppositeMotion + distance;
3242) 		animation.opacity = 1;
3243) 	}
3244) 
3245) 	// Animate
3246) 	element.animate( animation, {
3247) 		queue: false,
3248) 		duration: options.duration,
3249) 		easing: options.easing,
3250) 		complete: done
3251) 	} );
3252) } );
3253) 
3254) 
3255) /*!
3256)  * jQuery UI Effects Explode 1.13.2
3257)  * http://jqueryui.com
3258)  *
3259)  * Copyright jQuery Foundation and other contributors
3260)  * Released under the MIT license.
3261)  * http://jquery.org/license
3262)  */
3263) 
3264) //>>label: Explode Effect
3265) //>>group: Effects
3266) /* eslint-disable max-len */
3267) //>>description: Explodes an element in all directions into n pieces. Implodes an element to its original wholeness.
3268) /* eslint-enable max-len */
3269) //>>docs: http://api.jqueryui.com/explode-effect/
3270) //>>demos: http://jqueryui.com/effect/
3271) 
3272) 
3273) var effectsEffectExplode = $.effects.define( "explode", "hide", function( options, done ) {
3274) 
3275) 	var i, j, left, top, mx, my,
3276) 		rows = options.pieces ? Math.round( Math.sqrt( options.pieces ) ) : 3,
3277) 		cells = rows,
3278) 		element = $( this ),
3279) 		mode = options.mode,
3280) 		show = mode === "show",
3281) 
3282) 		// Show and then visibility:hidden the element before calculating offset
3283) 		offset = element.show().css( "visibility", "hidden" ).offset(),
3284) 
3285) 		// Width and height of a piece
3286) 		width = Math.ceil( element.outerWidth() / cells ),
3287) 		height = Math.ceil( element.outerHeight() / rows ),
3288) 		pieces = [];
3289) 
3290) 	// Children animate complete:
3291) 	function childComplete() {
3292) 		pieces.push( this );
3293) 		if ( pieces.length === rows * cells ) {
3294) 			animComplete();

3295) 		}

3296) 	}
3297) 
3298) 	// Clone the element for each row and cell.
3299) 	for ( i = 0; i < rows; i++ ) { // ===>
3300) 		top = offset.top + i * height;
3301) 		my = i - ( rows - 1 ) / 2;
3302) 
3303) 		for ( j = 0; j < cells; j++ ) { // |||
3304) 			left = offset.left + j * width;
3305) 			mx = j - ( cells - 1 ) / 2;
3306) 
3307) 			// Create a clone of the now hidden main element that will be absolute positioned
3308) 			// within a wrapper div off the -left and -top equal to size of our pieces
3309) 			element
3310) 				.clone()
3311) 				.appendTo( "body" )
3312) 				.wrap( "<div></div>" )
3313) 				.css( {
3314) 					position: "absolute",
3315) 					visibility: "visible",
3316) 					left: -j * width,
3317) 					top: -i * height
3318) 				} )
3319) 
3320) 				// Select the wrapper - make it overflow: hidden and absolute positioned based on
3321) 				// where the original was located +left and +top equal to the size of pieces
3322) 				.parent()
3323) 					.addClass( "ui-effects-explode" )
3324) 					.css( {
3325) 						position: "absolute",
3326) 						overflow: "hidden",
3327) 						width: width,
3328) 						height: height,
3329) 						left: left + ( show ? mx * width : 0 ),
3330) 						top: top + ( show ? my * height : 0 ),
3331) 						opacity: show ? 0 : 1
3332) 					} )
3333) 					.animate( {
3334) 						left: left + ( show ? 0 : mx * width ),
3335) 						top: top + ( show ? 0 : my * height ),
3336) 						opacity: show ? 1 : 0
3337) 					}, options.duration || 500, options.easing, childComplete );

3338) 		}

3339) 	}
3340) 
3341) 	function animComplete() {
3342) 		element.css( {
3343) 			visibility: "visible"
3344) 		} );
3345) 		$( pieces ).remove();
3346) 		done();
3347) 	}
3348) } );
3349) 
3350) 
3351) /*!
3352)  * jQuery UI Effects Fade 1.13.2
3353)  * http://jqueryui.com
3354)  *
3355)  * Copyright jQuery Foundation and other contributors
3356)  * Released under the MIT license.
3357)  * http://jquery.org/license
3358)  */
3359) 
3360) //>>label: Fade Effect
3361) //>>group: Effects
3362) //>>description: Fades the element.
3363) //>>docs: http://api.jqueryui.com/fade-effect/
3364) //>>demos: http://jqueryui.com/effect/
3365) 
3366) 
3367) var effectsEffectFade = $.effects.define( "fade", "toggle", function( options, done ) {
3368) 	var show = options.mode === "show";
3369) 
3370) 	$( this )
3371) 		.css( "opacity", show ? 0 : 1 )
3372) 		.animate( {
3373) 			opacity: show ? 1 : 0
3374) 		}, {
3375) 			queue: false,
3376) 			duration: options.duration,
3377) 			easing: options.easing,
3378) 			complete: done
3379) 		} );
3380) } );
3381) 
3382) 
3383) /*!
3384)  * jQuery UI Effects Fold 1.13.2
3385)  * http://jqueryui.com
3386)  *
3387)  * Copyright jQuery Foundation and other contributors
3388)  * Released under the MIT license.
3389)  * http://jquery.org/license
3390)  */
3391) 
3392) //>>label: Fold Effect
3393) //>>group: Effects
3394) //>>description: Folds an element first horizontally and then vertically.
3395) //>>docs: http://api.jqueryui.com/fold-effect/
3396) //>>demos: http://jqueryui.com/effect/
3397) 
3398) 
3399) var effectsEffectFold = $.effects.define( "fold", "hide", function( options, done ) {
3400) 
3401) 	// Create element
3402) 	var element = $( this ),
3403) 		mode = options.mode,
3404) 		show = mode === "show",
3405) 		hide = mode === "hide",
3406) 		size = options.size || 15,
3407) 		percent = /([0-9]+)%/.exec( size ),
3408) 		horizFirst = !!options.horizFirst,
3409) 		ref = horizFirst ? [ "right", "bottom" ] : [ "bottom", "right" ],
3410) 		duration = options.duration / 2,
3411) 
3412) 		placeholder = $.effects.createPlaceholder( element ),
3413) 
3414) 		start = element.cssClip(),
3415) 		animation1 = { clip: $.extend( {}, start ) },
3416) 		animation2 = { clip: $.extend( {}, start ) },
3417) 
3418) 		distance = [ start[ ref[ 0 ] ], start[ ref[ 1 ] ] ],
3419) 
3420) 		queuelen = element.queue().length;
3421) 
3422) 	if ( percent ) {
3423) 		size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
3424) 	}
3425) 	animation1.clip[ ref[ 0 ] ] = size;
3426) 	animation2.clip[ ref[ 0 ] ] = size;
3427) 	animation2.clip[ ref[ 1 ] ] = 0;
3428) 
3429) 	if ( show ) {
3430) 		element.cssClip( animation2.clip );
3431) 		if ( placeholder ) {
3432) 			placeholder.css( $.effects.clipToBox( animation2 ) );
3433) 		}
3434) 
3435) 		animation2.clip = start;
3436) 	}
3437) 
3438) 	// Animate
3439) 	element
3440) 		.queue( function( next ) {
3441) 			if ( placeholder ) {
3442) 				placeholder
3443) 					.animate( $.effects.clipToBox( animation1 ), duration, options.easing )
3444) 					.animate( $.effects.clipToBox( animation2 ), duration, options.easing );
3445) 			}
3446) 
3447) 			next();
3448) 		} )
3449) 		.animate( animation1, duration, options.easing )
3450) 		.animate( animation2, duration, options.easing )
3451) 		.queue( done );
3452) 
3453) 	$.effects.unshift( element, queuelen, 4 );
3454) } );
3455) 
3456) 
3457) /*!
3458)  * jQuery UI Effects Highlight 1.13.2
3459)  * http://jqueryui.com
3460)  *
3461)  * Copyright jQuery Foundation and other contributors
3462)  * Released under the MIT license.
3463)  * http://jquery.org/license
3464)  */
3465) 
3466) //>>label: Highlight Effect
3467) //>>group: Effects
3468) //>>description: Highlights the background of an element in a defined color for a custom duration.
3469) //>>docs: http://api.jqueryui.com/highlight-effect/
3470) //>>demos: http://jqueryui.com/effect/
3471) 
3472) 
3473) var effectsEffectHighlight = $.effects.define( "highlight", "show", function( options, done ) {
3474) 	var element = $( this ),
3475) 		animation = {
3476) 			backgroundColor: element.css( "backgroundColor" )
3477) 		};
3478) 
3479) 	if ( options.mode === "hide" ) {
3480) 		animation.opacity = 0;
3481) 	}
3482) 
3483) 	$.effects.saveStyle( element );
3484) 
3485) 	element
3486) 		.css( {
3487) 			backgroundImage: "none",
3488) 			backgroundColor: options.color || "#ffff99"
3489) 		} )
3490) 		.animate( animation, {
3491) 			queue: false,
3492) 			duration: options.duration,
3493) 			easing: options.easing,
3494) 			complete: done
3495) 		} );
3496) } );
3497) 
3498) 
3499) /*!
3500)  * jQuery UI Effects Size 1.13.2
3501)  * http://jqueryui.com
3502)  *
3503)  * Copyright jQuery Foundation and other contributors
3504)  * Released under the MIT license.
3505)  * http://jquery.org/license
3506)  */
3507) 
3508) //>>label: Size Effect
3509) //>>group: Effects
3510) //>>description: Resize an element to a specified width and height.
3511) //>>docs: http://api.jqueryui.com/size-effect/
3512) //>>demos: http://jqueryui.com/effect/
3513) 
3514) 
3515) var effectsEffectSize = $.effects.define( "size", function( options, done ) {
3516) 
3517) 	// Create element
3518) 	var baseline, factor, temp,
3519) 		element = $( this ),
3520) 
3521) 		// Copy for children
3522) 		cProps = [ "fontSize" ],
3523) 		vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
3524) 		hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
3525) 
3526) 		// Set options
3527) 		mode = options.mode,
3528) 		restore = mode !== "effect",
3529) 		scale = options.scale || "both",
3530) 		origin = options.origin || [ "middle", "center" ],
3531) 		position = element.css( "position" ),
3532) 		pos = element.position(),
3533) 		original = $.effects.scaledDimensions( element ),
3534) 		from = options.from || original,
3535) 		to = options.to || $.effects.scaledDimensions( element, 0 );
3536) 
3537) 	$.effects.createPlaceholder( element );
3538) 
3539) 	if ( mode === "show" ) {
3540) 		temp = from;
3541) 		from = to;
3542) 		to = temp;
3543) 	}
3544) 
3545) 	// Set scaling factor
3546) 	factor = {
3547) 		from: {
3548) 			y: from.height / original.height,
3549) 			x: from.width / original.width
3550) 		},
3551) 		to: {
3552) 			y: to.height / original.height,
3553) 			x: to.width / original.width
3554) 		}
3555) 	};
3556) 
3557) 	// Scale the css box
3558) 	if ( scale === "box" || scale === "both" ) {
3559) 
3560) 		// Vertical props scaling
3561) 		if ( factor.from.y !== factor.to.y ) {
3562) 			from = $.effects.setTransition( element, vProps, factor.from.y, from );
3563) 			to = $.effects.setTransition( element, vProps, factor.to.y, to );
3564) 		}
3565) 
3566) 		// Horizontal props scaling
3567) 		if ( factor.from.x !== factor.to.x ) {
3568) 			from = $.effects.setTransition( element, hProps, factor.from.x, from );
3569) 			to = $.effects.setTransition( element, hProps, factor.to.x, to );
3570) 		}
3571) 	}
3572) 
3573) 	// Scale the content
3574) 	if ( scale === "content" || scale === "both" ) {
3575) 
3576) 		// Vertical props scaling
3577) 		if ( factor.from.y !== factor.to.y ) {
3578) 			from = $.effects.setTransition( element, cProps, factor.from.y, from );
3579) 			to = $.effects.setTransition( element, cProps, factor.to.y, to );
3580) 		}
3581) 	}
3582) 
3583) 	// Adjust the position properties based on the provided origin points
3584) 	if ( origin ) {
3585) 		baseline = $.effects.getBaseline( origin, original );
3586) 		from.top = ( original.outerHeight - from.outerHeight ) * baseline.y + pos.top;
3587) 		from.left = ( original.outerWidth - from.outerWidth ) * baseline.x + pos.left;
3588) 		to.top = ( original.outerHeight - to.outerHeight ) * baseline.y + pos.top;
3589) 		to.left = ( original.outerWidth - to.outerWidth ) * baseline.x + pos.left;
3590) 	}
3591) 	delete from.outerHeight;
3592) 	delete from.outerWidth;
3593) 	element.css( from );
3594) 
3595) 	// Animate the children if desired
3596) 	if ( scale === "content" || scale === "both" ) {
3597) 
3598) 		vProps = vProps.concat( [ "marginTop", "marginBottom" ] ).concat( cProps );
3599) 		hProps = hProps.concat( [ "marginLeft", "marginRight" ] );
3600) 
3601) 		// Only animate children with width attributes specified
3602) 		// TODO: is this right? should we include anything with css width specified as well
3603) 		element.find( "*[width]" ).each( function() {
3604) 			var child = $( this ),
3605) 				childOriginal = $.effects.scaledDimensions( child ),
3606) 				childFrom = {
3607) 					height: childOriginal.height * factor.from.y,
3608) 					width: childOriginal.width * factor.from.x,
3609) 					outerHeight: childOriginal.outerHeight * factor.from.y,
3610) 					outerWidth: childOriginal.outerWidth * factor.from.x
3611) 				},
3612) 				childTo = {
3613) 					height: childOriginal.height * factor.to.y,
3614) 					width: childOriginal.width * factor.to.x,
3615) 					outerHeight: childOriginal.height * factor.to.y,
3616) 					outerWidth: childOriginal.width * factor.to.x
3617) 				};
3618) 
3619) 			// Vertical props scaling
3620) 			if ( factor.from.y !== factor.to.y ) {
3621) 				childFrom = $.effects.setTransition( child, vProps, factor.from.y, childFrom );
3622) 				childTo = $.effects.setTransition( child, vProps, factor.to.y, childTo );
3623) 			}
3624) 
3625) 			// Horizontal props scaling
3626) 			if ( factor.from.x !== factor.to.x ) {
3627) 				childFrom = $.effects.setTransition( child, hProps, factor.from.x, childFrom );
3628) 				childTo = $.effects.setTransition( child, hProps, factor.to.x, childTo );
3629) 			}
3630) 
3631) 			if ( restore ) {
3632) 				$.effects.saveStyle( child );
3633) 			}
3634) 
3635) 			// Animate children
3636) 			child.css( childFrom );
3637) 			child.animate( childTo, options.duration, options.easing, function() {
3638) 
3639) 				// Restore children
3640) 				if ( restore ) {
3641) 					$.effects.restoreStyle( child );
3642) 				}
3643) 			} );
3644) 		} );
3645) 	}
3646) 
3647) 	// Animate
3648) 	element.animate( to, {
3649) 		queue: false,
3650) 		duration: options.duration,
3651) 		easing: options.easing,
3652) 		complete: function() {

3653) 

3654) 			var offset = element.offset();

3655) 

3656) 			if ( to.opacity === 0 ) {
3657) 				element.css( "opacity", from.opacity );

3658) 			}
3659) 

3660) 			if ( !restore ) {
3661) 				element
3662) 					.css( "position", position === "static" ? "relative" : position )
3663) 					.offset( offset );

3664) 

3665) 				// Need to save style here so that automatic style restoration
3666) 				// doesn't restore to the original styles from before the animation.
3667) 				$.effects.saveStyle( element );
3668) 			}

3669) 

3670) 			done();

3671) 		}

3672) 	} );
3673) 
3674) } );
3675) 
3676) 
3677) /*!
3678)  * jQuery UI Effects Scale 1.13.2
3679)  * http://jqueryui.com
3680)  *
3681)  * Copyright jQuery Foundation and other contributors
3682)  * Released under the MIT license.
3683)  * http://jquery.org/license
3684)  */
3685) 
3686) //>>label: Scale Effect
3687) //>>group: Effects
3688) //>>description: Grows or shrinks an element and its content.
3689) //>>docs: http://api.jqueryui.com/scale-effect/
3690) //>>demos: http://jqueryui.com/effect/
3691) 
3692) 
3693) var effectsEffectScale = $.effects.define( "scale", function( options, done ) {
3694) 
3695) 	// Create element
3696) 	var el = $( this ),
3697) 		mode = options.mode,
3698) 		percent = parseInt( options.percent, 10 ) ||
3699) 			( parseInt( options.percent, 10 ) === 0 ? 0 : ( mode !== "effect" ? 0 : 100 ) ),
3700) 
3701) 		newOptions = $.extend( true, {
3702) 			from: $.effects.scaledDimensions( el ),
3703) 			to: $.effects.scaledDimensions( el, percent, options.direction || "both" ),
3704) 			origin: options.origin || [ "middle", "center" ]
3705) 		}, options );
3706) 
3707) 	// Fade option to support puff
3708) 	if ( options.fade ) {
3709) 		newOptions.from.opacity = 1;
3710) 		newOptions.to.opacity = 0;

3711) 	}

3712) 
3713) 	$.effects.effect.size.call( this, newOptions, done );
3714) } );

3715) 
3716) 
3717) /*!

3718)  * jQuery UI Effects Puff 1.13.2

3719)  * http://jqueryui.com
3720)  *
3721)  * Copyright jQuery Foundation and other contributors
3722)  * Released under the MIT license.
3723)  * http://jquery.org/license

3724)  */
3725) 
3726) //>>label: Puff Effect
3727) //>>group: Effects
3728) //>>description: Creates a puff effect by scaling the element up and hiding it at the same time.
3729) //>>docs: http://api.jqueryui.com/puff-effect/
3730) //>>demos: http://jqueryui.com/effect/
3731) 
3732) 
3733) var effectsEffectPuff = $.effects.define( "puff", "hide", function( options, done ) {
3734) 	var newOptions = $.extend( true, {}, options, {
3735) 		fade: true,
3736) 		percent: parseInt( options.percent, 10 ) || 150
3737) 	} );
3738) 
3739) 	$.effects.effect.scale.call( this, newOptions, done );
3740) } );
3741) 
3742) 
3743) /*!
3744)  * jQuery UI Effects Pulsate 1.13.2
3745)  * http://jqueryui.com

3746)  *

3747)  * Copyright jQuery Foundation and other contributors
3748)  * Released under the MIT license.
3749)  * http://jquery.org/license

3750)  */
3751) 

3752) //>>label: Pulsate Effect
3753) //>>group: Effects
3754) //>>description: Pulsates an element n times by changing the opacity to zero and back.
3755) //>>docs: http://api.jqueryui.com/pulsate-effect/
3756) //>>demos: http://jqueryui.com/effect/

3757) 
3758) 

3759) var effectsEffectPulsate = $.effects.define( "pulsate", "show", function( options, done ) {
3760) 	var element = $( this ),
3761) 		mode = options.mode,
3762) 		show = mode === "show",
3763) 		hide = mode === "hide",
3764) 		showhide = show || hide,

3765) 

3766) 		// Showing or hiding leaves off the "last" animation
3767) 		anims = ( ( options.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
3768) 		duration = options.duration / anims,
3769) 		animateTo = 0,
3770) 		i = 1,
3771) 		queuelen = element.queue().length;

3772) 

3773) 	if ( show || !element.is( ":visible" ) ) {
3774) 		element.css( "opacity", 0 ).show();
3775) 		animateTo = 1;
3776) 	}

3777) 

3778) 	// Anims - 1 opacity "toggles"
3779) 	for ( ; i < anims; i++ ) {
3780) 		element.animate( { opacity: animateTo }, duration, options.easing );
3781) 		animateTo = 1 - animateTo;
3782) 	}

3783) 

3784) 	element.animate( { opacity: animateTo }, duration, options.easing );

3785) 

3786) 	element.queue( done );

3787) 

3788) 	$.effects.unshift( element, queuelen, anims + 1 );
3789) } );

3790) 
3791) 

3792) /*!
3793)  * jQuery UI Effects Shake 1.13.2
3794)  * http://jqueryui.com
3795)  *
3796)  * Copyright jQuery Foundation and other contributors
3797)  * Released under the MIT license.
3798)  * http://jquery.org/license
3799)  */

3800) 

3801) //>>label: Shake Effect
3802) //>>group: Effects
3803) //>>description: Shakes an element horizontally or vertically n times.
3804) //>>docs: http://api.jqueryui.com/shake-effect/
3805) //>>demos: http://jqueryui.com/effect/

3806) 
3807) 

3808) var effectsEffectShake = $.effects.define( "shake", function( options, done ) {

3809) 

3810) 	var i = 1,
3811) 		element = $( this ),
3812) 		direction = options.direction || "left",
3813) 		distance = options.distance || 20,
3814) 		times = options.times || 3,
3815) 		anims = times * 2 + 1,
3816) 		speed = Math.round( options.duration / anims ),
3817) 		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3818) 		positiveMotion = ( direction === "up" || direction === "left" ),
3819) 		animation = {},
3820) 		animation1 = {},
3821) 		animation2 = {},

3822) 

3823) 		queuelen = element.queue().length;

3824) 

3825) 	$.effects.createPlaceholder( element );

3826) 

3827) 	// Animation
3828) 	animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
3829) 	animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
3830) 	animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;

3831) 

3832) 	// Animate
3833) 	element.animate( animation, speed, options.easing );

3834) 

3835) 	// Shakes
3836) 	for ( ; i < times; i++ ) {
3837) 		element
3838) 			.animate( animation1, speed, options.easing )
3839) 			.animate( animation2, speed, options.easing );
3840) 	}

3841) 

3842) 	element
3843) 		.animate( animation1, speed, options.easing )
3844) 		.animate( animation, speed / 2, options.easing )
3845) 		.queue( done );

3846) 

3847) 	$.effects.unshift( element, queuelen, anims + 1 );
3848) } );

3849) 
3850) 

3851) /*!
3852)  * jQuery UI Effects Slide 1.13.2
3853)  * http://jqueryui.com
3854)  *
3855)  * Copyright jQuery Foundation and other contributors
3856)  * Released under the MIT license.
3857)  * http://jquery.org/license
3858)  */
3859) 
3860) //>>label: Slide Effect
3861) //>>group: Effects
3862) //>>description: Slides an element in and out of the viewport.
3863) //>>docs: http://api.jqueryui.com/slide-effect/
3864) //>>demos: http://jqueryui.com/effect/
3865) 
3866) 
3867) var effectsEffectSlide = $.effects.define( "slide", "show", function( options, done ) {
3868) 	var startClip, startRef,
3869) 		element = $( this ),
3870) 		map = {
3871) 			up: [ "bottom", "top" ],
3872) 			down: [ "top", "bottom" ],
3873) 			left: [ "right", "left" ],
3874) 			right: [ "left", "right" ]
3875) 		},
3876) 		mode = options.mode,
3877) 		direction = options.direction || "left",
3878) 		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3879) 		positiveMotion = ( direction === "up" || direction === "left" ),
3880) 		distance = options.distance ||
3881) 			element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ),
3882) 		animation = {};
3883) 
3884) 	$.effects.createPlaceholder( element );

3885) 

3886) 	startClip = element.cssClip();
3887) 	startRef = element.position()[ ref ];

3888) 

3889) 	// Define hide animation
3890) 	animation[ ref ] = ( positiveMotion ? -1 : 1 ) * distance + startRef;
3891) 	animation.clip = element.cssClip();
3892) 	animation.clip[ map[ direction ][ 1 ] ] = animation.clip[ map[ direction ][ 0 ] ];

3893) 

3894) 	// Reverse the animation if we're showing
3895) 	if ( mode === "show" ) {
3896) 		element.cssClip( animation.clip );
3897) 		element.css( ref, animation[ ref ] );
3898) 		animation.clip = startClip;
3899) 		animation[ ref ] = startRef;
3900) 	}

3901) 

3902) 	// Actually animate
3903) 	element.animate( animation, {
3904) 		queue: false,
3905) 		duration: options.duration,
3906) 		easing: options.easing,
3907) 		complete: done
3908) 	} );
3909) } );

3910) 
3911) 

3912) /*!
3913)  * jQuery UI Effects Transfer 1.13.2
3914)  * http://jqueryui.com
3915)  *
3916)  * Copyright jQuery Foundation and other contributors
3917)  * Released under the MIT license.
3918)  * http://jquery.org/license
3919)  */

3920) 

3921) //>>label: Transfer Effect
3922) //>>group: Effects
3923) //>>description: Displays a transfer effect from one element to another.
3924) //>>docs: http://api.jqueryui.com/transfer-effect/
3925) //>>demos: http://jqueryui.com/effect/

3926) 
3927) 

3928) var effect;
3929) if ( $.uiBackCompat !== false ) {
3930) 	effect = $.effects.define( "transfer", function( options, done ) {
3931) 		$( this ).transfer( options, done );
3932) 	} );
3933) }
3934) var effectsEffectTransfer = effect;

3935) 
3936) 

3937) /*!
3938)  * jQuery UI Focusable 1.13.2
3939)  * http://jqueryui.com
3940)  *
3941)  * Copyright jQuery Foundation and other contributors
3942)  * Released under the MIT license.
3943)  * http://jquery.org/license
3944)  */

3945) 

3946) //>>label: :focusable Selector
3947) //>>group: Core
3948) //>>description: Selects elements which can be focused.
3949) //>>docs: http://api.jqueryui.com/focusable-selector/

3950) 
3951) 

3952) // Selectors
3953) $.ui.focusable = function( element, hasTabindex ) {
3954) 	var map, mapName, img, focusableIfVisible, fieldset,
3955) 		nodeName = element.nodeName.toLowerCase();
3956) 
3957) 	if ( "area" === nodeName ) {
3958) 		map = element.parentNode;
3959) 		mapName = map.name;
3960) 		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
3961) 			return false;

3962) 		}

3963) 		img = $( "img[usemap='#" + mapName + "']" );
3964) 		return img.length > 0 && img.is( ":visible" );
3965) 	}

3966) 

3967) 	if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
3968) 		focusableIfVisible = !element.disabled;

3969) 

3970) 		if ( focusableIfVisible ) {

3971) 

3972) 			// Form controls within a disabled fieldset are disabled.
3973) 			// However, controls within the fieldset's legend do not get disabled.
3974) 			// Since controls generally aren't placed inside legends, we skip
3975) 			// this portion of the check.
3976) 			fieldset = $( element ).closest( "fieldset" )[ 0 ];
3977) 			if ( fieldset ) {
3978) 				focusableIfVisible = !fieldset.disabled;
3979) 			}

3980) 		}

3981) 	} else if ( "a" === nodeName ) {
3982) 		focusableIfVisible = element.href || hasTabindex;
3983) 	} else {
3984) 		focusableIfVisible = hasTabindex;
3985) 	}

3986) 

3987) 	return focusableIfVisible && $( element ).is( ":visible" ) && visible( $( element ) );
3988) };

3989) 

3990) // Support: IE 8 only
3991) // IE 8 doesn't resolve inherit to visible/hidden for computed values
3992) function visible( element ) {
3993) 	var visibility = element.css( "visibility" );
3994) 	while ( visibility === "inherit" ) {
3995) 		element = element.parent();
3996) 		visibility = element.css( "visibility" );
3997) 	}
3998) 	return visibility === "visible";
3999) }

4000) 

4001) $.extend( $.expr.pseudos, {
4002) 	focusable: function( element ) {
4003) 		return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
4004) 	}
4005) } );

4006) 

4007) var focusable = $.ui.focusable;

4008) 
4009) 
4010) 

4011) // Support: IE8 Only
4012) // IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
4013) // with a string, so we need to find the proper form.
4014) var form = $.fn._form = function() {
4015) 	return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form );
4016) };

4017) 
4018) 

4019) /*!
4020)  * jQuery UI Form Reset Mixin 1.13.2
4021)  * http://jqueryui.com
4022)  *
4023)  * Copyright jQuery Foundation and other contributors
4024)  * Released under the MIT license.
4025)  * http://jquery.org/license
4026)  */

4027) 

4028) //>>label: Form Reset Mixin
4029) //>>group: Core
4030) //>>description: Refresh input widgets when their form is reset
4031) //>>docs: http://api.jqueryui.com/form-reset-mixin/

4032) 
4033) 

4034) var formResetMixin = $.ui.formResetMixin = {
4035) 	_formResetHandler: function() {
4036) 		var form = $( this );
4037) 
4038) 		// Wait for the form reset to actually happen before refreshing
4039) 		setTimeout( function() {
4040) 			var instances = form.data( "ui-form-reset-instances" );
4041) 			$.each( instances, function() {
4042) 				this.refresh();
4043) 			} );
4044) 		} );
4045) 	},
4046) 
4047) 	_bindFormResetHandler: function() {
4048) 		this.form = this.element._form();
4049) 		if ( !this.form.length ) {

4050) 			return;
4051) 		}
4052) 

4053) 		var instances = this.form.data( "ui-form-reset-instances" ) || [];
4054) 		if ( !instances.length ) {
4055) 
4056) 			// We don't use _on() here because we use a single event handler per form
4057) 			this.form.on( "reset.ui-form-reset", this._formResetHandler );
4058) 		}
4059) 		instances.push( this );
4060) 		this.form.data( "ui-form-reset-instances", instances );

4061) 	},
4062) 

4063) 	_unbindFormResetHandler: function() {
4064) 		if ( !this.form.length ) {
4065) 			return;
4066) 		}

4067) 

4068) 		var instances = this.form.data( "ui-form-reset-instances" );
4069) 		instances.splice( $.inArray( this, instances ), 1 );
4070) 		if ( instances.length ) {
4071) 			this.form.data( "ui-form-reset-instances", instances );
4072) 		} else {
4073) 			this.form
4074) 				.removeData( "ui-form-reset-instances" )
4075) 				.off( "reset.ui-form-reset" );
4076) 		}
4077) 	}
4078) };

4079) 
4080) 

4081) /*!
4082)  * jQuery UI Support for jQuery core 1.8.x and newer 1.13.2
4083)  * http://jqueryui.com
4084)  *
4085)  * Copyright jQuery Foundation and other contributors
4086)  * Released under the MIT license.
4087)  * http://jquery.org/license
4088)  *
4089)  */

4090) 

4091) //>>label: jQuery 1.8+ Support
4092) //>>group: Core
4093) //>>description: Support version 1.8.x and newer of jQuery core

4094) 
4095) 

4096) // Support: jQuery 1.9.x or older
4097) // $.expr[ ":" ] is deprecated.
4098) if ( !$.expr.pseudos ) {
4099) 	$.expr.pseudos = $.expr[ ":" ];
4100) }

4101) 

4102) // Support: jQuery 1.11.x or older
4103) // $.unique has been renamed to $.uniqueSort
4104) if ( !$.uniqueSort ) {
4105) 	$.uniqueSort = $.unique;
4106) }

4107) 

4108) // Support: jQuery 2.2.x or older.
4109) // This method has been defined in jQuery 3.0.0.
4110) // Code from https://github.com/jquery/jquery/blob/e539bac79e666bba95bba86d690b4e609dca2286/src/selector/escapeSelector.js
4111) if ( !$.escapeSelector ) {

4112) 

4113) 	// CSS string/identifier serialization
4114) 	// https://drafts.csswg.org/cssom/#common-serializing-idioms
4115) 	var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;

4116) 

4117) 	var fcssescape = function( ch, asCodePoint ) {
4118) 		if ( asCodePoint ) {

4119) 

4120) 			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
4121) 			if ( ch === "\0" ) {
4122) 				return "\uFFFD";
4123) 			}

4124) 

4125) 			// Control characters and (dependent upon position) numbers get escaped as code points
4126) 			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";

4127) 		}
4128) 

4129) 		// Other potentially-special ASCII characters get backslash-escaped
4130) 		return "\\" + ch;
4131) 	};

4132) 

4133) 	$.escapeSelector = function( sel ) {
4134) 		return ( sel + "" ).replace( rcssescape, fcssescape );
4135) 	};
4136) }

4137) 

4138) // Support: jQuery 3.4.x or older
4139) // These methods have been defined in jQuery 3.5.0.
4140) if ( !$.fn.even || !$.fn.odd ) {
4141) 	$.fn.extend( {
4142) 		even: function() {
4143) 			return this.filter( function( i ) {
4144) 				return i % 2 === 0;
4145) 			} );
4146) 		},
4147) 		odd: function() {
4148) 			return this.filter( function( i ) {
4149) 				return i % 2 === 1;
4150) 			} );

4151) 		}

4152) 	} );
4153) }

4154) 

4155) ;
4156) /*!
4157)  * jQuery UI Keycode 1.13.2
4158)  * http://jqueryui.com
4159)  *
4160)  * Copyright jQuery Foundation and other contributors
4161)  * Released under the MIT license.
4162)  * http://jquery.org/license
4163)  */

4164) 

4165) //>>label: Keycode
4166) //>>group: Core
4167) //>>description: Provide keycodes as keynames
4168) //>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
4169) 
4170) 
4171) var keycode = $.ui.keyCode = {
4172) 	BACKSPACE: 8,
4173) 	COMMA: 188,
4174) 	DELETE: 46,
4175) 	DOWN: 40,
4176) 	END: 35,
4177) 	ENTER: 13,
4178) 	ESCAPE: 27,
4179) 	HOME: 36,
4180) 	LEFT: 37,
4181) 	PAGE_DOWN: 34,
4182) 	PAGE_UP: 33,
4183) 	PERIOD: 190,
4184) 	RIGHT: 39,
4185) 	SPACE: 32,
4186) 	TAB: 9,
4187) 	UP: 38
4188) };

4189) 
4190) 

4191) /*!
4192)  * jQuery UI Labels 1.13.2
4193)  * http://jqueryui.com
4194)  *
4195)  * Copyright jQuery Foundation and other contributors
4196)  * Released under the MIT license.
4197)  * http://jquery.org/license
4198)  */

4199) 

4200) //>>label: labels
4201) //>>group: Core
4202) //>>description: Find all the labels associated with a given input
4203) //>>docs: http://api.jqueryui.com/labels/

4204) 
4205) 

4206) var labels = $.fn.labels = function() {
4207) 	var ancestor, selector, id, labels, ancestors;

4208) 

4209) 	if ( !this.length ) {
4210) 		return this.pushStack( [] );
4211) 	}

4212) 

4213) 	// Check control.labels first
4214) 	if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
4215) 		return this.pushStack( this[ 0 ].labels );
4216) 	}

4217) 

4218) 	// Support: IE <= 11, FF <= 37, Android <= 2.3 only
4219) 	// Above browsers do not support control.labels. Everything below is to support them
4220) 	// as well as document fragments. control.labels does not work on document fragments
4221) 	labels = this.eq( 0 ).parents( "label" );

4222) 

4223) 	// Look for the label based on the id
4224) 	id = this.attr( "id" );
4225) 	if ( id ) {

4226) 

4227) 		// We don't search against the document in case the element
4228) 		// is disconnected from the DOM
4229) 		ancestor = this.eq( 0 ).parents().last();

4230) 

4231) 		// Get a full set of top level ancestors
4232) 		ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );

4233) 

4234) 		// Create a selector for the label based on the id
4235) 		selector = "label[for='" + $.escapeSelector( id ) + "']";

4236) 

4237) 		labels = labels.add( ancestors.find( selector ).addBack( selector ) );

4238) 
4239) 	}

4240) 
4241) 	// Return whatever we have found for labels
4242) 	return this.pushStack( labels );
4243) };

4244) 
4245) 
4246) /*!

4247)  * jQuery UI Scroll Parent 1.13.2

4248)  * http://jqueryui.com
4249)  *
4250)  * Copyright jQuery Foundation and other contributors
4251)  * Released under the MIT license.
4252)  * http://jquery.org/license
4253)  */
4254) 

4255) //>>label: scrollParent
4256) //>>group: Core
4257) //>>description: Get the closest ancestor element that is scrollable.
4258) //>>docs: http://api.jqueryui.com/scrollParent/

4259) 
4260) 

4261) var scrollParent = $.fn.scrollParent = function( includeHidden ) {
4262) 	var position = this.css( "position" ),
4263) 		excludeStaticParent = position === "absolute",
4264) 		overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
4265) 		scrollParent = this.parents().filter( function() {
4266) 			var parent = $( this );
4267) 			if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
4268) 				return false;
4269) 			}
4270) 			return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) +
4271) 				parent.css( "overflow-x" ) );
4272) 		} ).eq( 0 );

4273) 

4274) 	return position === "fixed" || !scrollParent.length ?
4275) 		$( this[ 0 ].ownerDocument || document ) :
4276) 		scrollParent;
4277) };

4278) 
4279) 

4280) /*!
4281)  * jQuery UI Tabbable 1.13.2
4282)  * http://jqueryui.com
4283)  *
4284)  * Copyright jQuery Foundation and other contributors
4285)  * Released under the MIT license.
4286)  * http://jquery.org/license
4287)  */

4288) 

4289) //>>label: :tabbable Selector
4290) //>>group: Core
4291) //>>description: Selects elements which can be tabbed to.
4292) //>>docs: http://api.jqueryui.com/tabbable-selector/

4293) 
4294) 

4295) var tabbable = $.extend( $.expr.pseudos, {
4296) 	tabbable: function( element ) {
4297) 		var tabIndex = $.attr( element, "tabindex" ),
4298) 			hasTabindex = tabIndex != null;
4299) 		return ( !hasTabindex || tabIndex >= 0 ) && $.ui.focusable( element, hasTabindex );
4300) 	}
4301) } );

4302) 
4303) 

4304) /*!
4305)  * jQuery UI Unique ID 1.13.2
4306)  * http://jqueryui.com
4307)  *
4308)  * Copyright jQuery Foundation and other contributors
4309)  * Released under the MIT license.
4310)  * http://jquery.org/license
4311)  */
4312) 
4313) //>>label: uniqueId
4314) //>>group: Core
4315) //>>description: Functions to generate and remove uniqueId's
4316) //>>docs: http://api.jqueryui.com/uniqueId/
4317) 
4318) 
4319) var uniqueId = $.fn.extend( {
4320) 	uniqueId: ( function() {
4321) 		var uuid = 0;
4322) 
4323) 		return function() {
4324) 			return this.each( function() {
4325) 				if ( !this.id ) {
4326) 					this.id = "ui-id-" + ( ++uuid );

4327) 				}

4328) 			} );
4329) 		};
4330) 	} )(),

4331) 

4332) 	removeUniqueId: function() {
4333) 		return this.each( function() {
4334) 			if ( /^ui-id-\d+$/.test( this.id ) ) {
4335) 				$( this ).removeAttr( "id" );

4336) 			}

4337) 		} );
4338) 	}
4339) } );

4340) 
4341) 

4342) /*!
4343)  * jQuery UI Accordion 1.13.2
4344)  * http://jqueryui.com
4345)  *
4346)  * Copyright jQuery Foundation and other contributors
4347)  * Released under the MIT license.
4348)  * http://jquery.org/license
4349)  */

4350) 

4351) //>>label: Accordion
4352) //>>group: Widgets
4353) /* eslint-disable max-len */
4354) //>>description: Displays collapsible content panels for presenting information in a limited amount of space.
4355) /* eslint-enable max-len */
4356) //>>docs: http://api.jqueryui.com/accordion/
4357) //>>demos: http://jqueryui.com/accordion/
4358) //>>css.structure: ../../themes/base/core.css
4359) //>>css.structure: ../../themes/base/accordion.css
4360) //>>css.theme: ../../themes/base/theme.css

4361) 
4362) 

4363) var widgetsAccordion = $.widget( "ui.accordion", {
4364) 	version: "1.13.2",
4365) 	options: {
4366) 		active: 0,
4367) 		animate: {},
4368) 		classes: {
4369) 			"ui-accordion-header": "ui-corner-top",
4370) 			"ui-accordion-header-collapsed": "ui-corner-all",
4371) 			"ui-accordion-content": "ui-corner-bottom"
4372) 		},
4373) 		collapsible: false,
4374) 		event: "click",
4375) 		header: function( elem ) {
4376) 			return elem.find( "> li > :first-child" ).add( elem.find( "> :not(li)" ).even() );
4377) 		},
4378) 		heightStyle: "auto",
4379) 		icons: {
4380) 			activeHeader: "ui-icon-triangle-1-s",
4381) 			header: "ui-icon-triangle-1-e"
4382) 		},

4383) 

4384) 		// Callbacks
4385) 		activate: null,
4386) 		beforeActivate: null
4387) 	},

4388) 

4389) 	hideProps: {
4390) 		borderTopWidth: "hide",
4391) 		borderBottomWidth: "hide",
4392) 		paddingTop: "hide",
4393) 		paddingBottom: "hide",
4394) 		height: "hide"
4395) 	},

4396) 

4397) 	showProps: {
4398) 		borderTopWidth: "show",
4399) 		borderBottomWidth: "show",
4400) 		paddingTop: "show",
4401) 		paddingBottom: "show",
4402) 		height: "show"
4403) 	},

4404) 

4405) 	_create: function() {
4406) 		var options = this.options;

4407) 

4408) 		this.prevShow = this.prevHide = $();
4409) 		this._addClass( "ui-accordion", "ui-widget ui-helper-reset" );
4410) 		this.element.attr( "role", "tablist" );

4411) 

4412) 		// Don't allow collapsible: false and active: false / null
4413) 		if ( !options.collapsible && ( options.active === false || options.active == null ) ) {
4414) 			options.active = 0;
4415) 		}

4416) 

4417) 		this._processPanels();
4418) 
4419) 		// handle negative values
4420) 		if ( options.active < 0 ) {
4421) 			options.active += this.headers.length;
4422) 		}
4423) 		this._refresh();
4424) 	},
4425) 
4426) 	_getCreateEventData: function() {
4427) 		return {
4428) 			header: this.active,
4429) 			panel: !this.active.length ? $() : this.active.next()
4430) 		};
4431) 	},
4432) 
4433) 	_createIcons: function() {
4434) 		var icon, children,
4435) 			icons = this.options.icons;
4436) 
4437) 		if ( icons ) {
4438) 			icon = $( "<span>" );
4439) 			this._addClass( icon, "ui-accordion-header-icon", "ui-icon " + icons.header );
4440) 			icon.prependTo( this.headers );
4441) 			children = this.active.children( ".ui-accordion-header-icon" );
4442) 			this._removeClass( children, icons.header )
4443) 				._addClass( children, null, icons.activeHeader )
4444) 				._addClass( this.headers, "ui-accordion-icons" );
4445) 		}
4446) 	},
4447) 
4448) 	_destroyIcons: function() {
4449) 		this._removeClass( this.headers, "ui-accordion-icons" );
4450) 		this.headers.children( ".ui-accordion-header-icon" ).remove();

4451) 	},
4452) 
4453) 	_destroy: function() {

4454) 		var contents;
4455) 
4456) 		// Clean up main element
4457) 		this.element.removeAttr( "role" );
4458) 
4459) 		// Clean up headers
4460) 		this.headers
4461) 			.removeAttr( "role aria-expanded aria-selected aria-controls tabIndex" )
4462) 			.removeUniqueId();
4463) 
4464) 		this._destroyIcons();
4465) 
4466) 		// Clean up content panels
4467) 		contents = this.headers.next()
4468) 			.css( "display", "" )
4469) 			.removeAttr( "role aria-hidden aria-labelledby" )
4470) 			.removeUniqueId();
4471) 
4472) 		if ( this.options.heightStyle !== "content" ) {
4473) 			contents.css( "height", "" );
4474) 		}

4475) 	},
4476) 
4477) 	_setOption: function( key, value ) {

4478) 		if ( key === "active" ) {
4479) 
4480) 			// _activate() will handle invalid values and update this.options
4481) 			this._activate( value );
4482) 			return;
4483) 		}
4484) 
4485) 		if ( key === "event" ) {
4486) 			if ( this.options.event ) {
4487) 				this._off( this.headers, this.options.event );
4488) 			}
4489) 			this._setupEvents( value );
4490) 		}
4491) 

4492) 		this._super( key, value );

4493) 
4494) 		// Setting collapsible: false while collapsed; open first panel
4495) 		if ( key === "collapsible" && !value && this.options.active === false ) {
4496) 			this._activate( 0 );

4497) 		}

4498) 
4499) 		if ( key === "icons" ) {
4500) 			this._destroyIcons();
4501) 			if ( value ) {
4502) 				this._createIcons();
4503) 			}

4504) 		}

4505) 	},
4506) 
4507) 	_setOptionDisabled: function( value ) {
4508) 		this._super( value );
4509) 
4510) 		this.element.attr( "aria-disabled", value );
4511) 
4512) 		// Support: IE8 Only
4513) 		// #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
4514) 		// so we need to add the disabled class to the headers and panels
4515) 		this._toggleClass( null, "ui-state-disabled", !!value );
4516) 		this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
4517) 			!!value );
4518) 	},
4519) 
4520) 	_keydown: function( event ) {
4521) 		if ( event.altKey || event.ctrlKey ) {
4522) 			return;
4523) 		}
4524) 
4525) 		var keyCode = $.ui.keyCode,
4526) 			length = this.headers.length,
4527) 			currentIndex = this.headers.index( event.target ),
4528) 			toFocus = false;
4529) 
4530) 		switch ( event.keyCode ) {
4531) 		case keyCode.RIGHT:
4532) 		case keyCode.DOWN:
4533) 			toFocus = this.headers[ ( currentIndex + 1 ) % length ];
4534) 			break;
4535) 		case keyCode.LEFT:
4536) 		case keyCode.UP:
4537) 			toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
4538) 			break;
4539) 		case keyCode.SPACE:
4540) 		case keyCode.ENTER:
4541) 			this._eventHandler( event );
4542) 			break;
4543) 		case keyCode.HOME:
4544) 			toFocus = this.headers[ 0 ];
4545) 			break;
4546) 		case keyCode.END:
4547) 			toFocus = this.headers[ length - 1 ];
4548) 			break;
4549) 		}
4550) 
4551) 		if ( toFocus ) {
4552) 			$( event.target ).attr( "tabIndex", -1 );
4553) 			$( toFocus ).attr( "tabIndex", 0 );
4554) 			$( toFocus ).trigger( "focus" );
4555) 			event.preventDefault();
4556) 		}
4557) 	},
4558) 
4559) 	_panelKeyDown: function( event ) {
4560) 		if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
4561) 			$( event.currentTarget ).prev().trigger( "focus" );
4562) 		}
4563) 	},
4564) 
4565) 	refresh: function() {
4566) 		var options = this.options;
4567) 		this._processPanels();
4568) 
4569) 		// Was collapsed or no panel
4570) 		if ( ( options.active === false && options.collapsible === true ) ||
4571) 				!this.headers.length ) {
4572) 			options.active = false;
4573) 			this.active = $();
4574) 
4575) 		// active false only when collapsible is true
4576) 		} else if ( options.active === false ) {
4577) 			this._activate( 0 );
4578) 
4579) 		// was active, but active panel is gone
4580) 		} else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
4581) 
4582) 			// all remaining panel are disabled
4583) 			if ( this.headers.length === this.headers.find( ".ui-state-disabled" ).length ) {
4584) 				options.active = false;
4585) 				this.active = $();
4586) 
4587) 			// activate previous panel
4588) 			} else {
4589) 				this._activate( Math.max( 0, options.active - 1 ) );
4590) 			}
4591) 
4592) 		// was active, active panel still exists
4593) 		} else {
4594) 
4595) 			// make sure active index is correct
4596) 			options.active = this.headers.index( this.active );

4597) 		}

4598) 
4599) 		this._destroyIcons();
4600) 
4601) 		this._refresh();

4602) 	},
4603) 

4604) 	_processPanels: function() {
4605) 		var prevHeaders = this.headers,
4606) 			prevPanels = this.panels;

4607) 

4608) 		if ( typeof this.options.header === "function" ) {
4609) 			this.headers = this.options.header( this.element );
4610) 		} else {
4611) 			this.headers = this.element.find( this.options.header );

4612) 		}

4613) 		this._addClass( this.headers, "ui-accordion-header ui-accordion-header-collapsed",
4614) 			"ui-state-default" );

4615) 

4616) 		this.panels = this.headers.next().filter( ":not(.ui-accordion-content-active)" ).hide();
4617) 		this._addClass( this.panels, "ui-accordion-content", "ui-helper-reset ui-widget-content" );

4618) 

4619) 		// Avoid memory leaks (#10056)
4620) 		if ( prevPanels ) {
4621) 			this._off( prevHeaders.not( this.headers ) );
4622) 			this._off( prevPanels.not( this.panels ) );

4623) 		}
4624) 	},
4625) 

4626) 	_refresh: function() {
4627) 		var maxHeight,
4628) 			options = this.options,
4629) 			heightStyle = options.heightStyle,
4630) 			parent = this.element.parent();
4631) 
4632) 		this.active = this._findActive( options.active );
4633) 		this._addClass( this.active, "ui-accordion-header-active", "ui-state-active" )
4634) 			._removeClass( this.active, "ui-accordion-header-collapsed" );
4635) 		this._addClass( this.active.next(), "ui-accordion-content-active" );
4636) 		this.active.next().show();
4637) 
4638) 		this.headers
4639) 			.attr( "role", "tab" )
4640) 			.each( function() {
4641) 				var header = $( this ),
4642) 					headerId = header.uniqueId().attr( "id" ),
4643) 					panel = header.next(),
4644) 					panelId = panel.uniqueId().attr( "id" );
4645) 				header.attr( "aria-controls", panelId );
4646) 				panel.attr( "aria-labelledby", headerId );
4647) 			} )
4648) 			.next()
4649) 				.attr( "role", "tabpanel" );
4650) 
4651) 		this.headers
4652) 			.not( this.active )
4653) 				.attr( {
4654) 					"aria-selected": "false",
4655) 					"aria-expanded": "false",
4656) 					tabIndex: -1
4657) 				} )
4658) 				.next()
4659) 					.attr( {
4660) 						"aria-hidden": "true"
4661) 					} )
4662) 					.hide();
4663) 
4664) 		// Make sure at least one header is in the tab order
4665) 		if ( !this.active.length ) {
4666) 			this.headers.eq( 0 ).attr( "tabIndex", 0 );

4667) 		} else {

4668) 			this.active.attr( {
4669) 				"aria-selected": "true",
4670) 				"aria-expanded": "true",
4671) 				tabIndex: 0
4672) 			} )
4673) 				.next()
4674) 					.attr( {
4675) 						"aria-hidden": "false"
4676) 					} );

4677) 		}
4678) 

4679) 		this._createIcons();

4680) 

4681) 		this._setupEvents( options.event );

4682) 

4683) 		if ( heightStyle === "fill" ) {
4684) 			maxHeight = parent.height();
4685) 			this.element.siblings( ":visible" ).each( function() {
4686) 				var elem = $( this ),
4687) 					position = elem.css( "position" );

4688) 

4689) 				if ( position === "absolute" || position === "fixed" ) {
4690) 					return;
4691) 				}
4692) 				maxHeight -= elem.outerHeight( true );
4693) 			} );

4694) 

4695) 			this.headers.each( function() {
4696) 				maxHeight -= $( this ).outerHeight( true );
4697) 			} );

4698) 

4699) 			this.headers.next()
4700) 				.each( function() {
4701) 					$( this ).height( Math.max( 0, maxHeight -
4702) 						$( this ).innerHeight() + $( this ).height() ) );
4703) 				} )
4704) 				.css( "overflow", "auto" );
4705) 		} else if ( heightStyle === "auto" ) {
4706) 			maxHeight = 0;
4707) 			this.headers.next()
4708) 				.each( function() {
4709) 					var isVisible = $( this ).is( ":visible" );
4710) 					if ( !isVisible ) {
4711) 						$( this ).show();
4712) 					}
4713) 					maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
4714) 					if ( !isVisible ) {
4715) 						$( this ).hide();
4716) 					}
4717) 				} )
4718) 				.height( maxHeight );

4719) 		}

4720) 	},

4721) 

4722) 	_activate: function( index ) {
4723) 		var active = this._findActive( index )[ 0 ];
4724) 
4725) 		// Trying to activate the already active panel
4726) 		if ( active === this.active[ 0 ] ) {

4727) 			return;
4728) 		}
4729) 

4730) 		// Trying to collapse, simulate a click on the currently active header
4731) 		active = active || this.active[ 0 ];
4732) 
4733) 		this._eventHandler( {
4734) 			target: active,
4735) 			currentTarget: active,
4736) 			preventDefault: $.noop
4737) 		} );

4738) 	},
4739) 

4740) 	_findActive: function( selector ) {
4741) 		return typeof selector === "number" ? this.headers.eq( selector ) : $();
4742) 	},

4743) 

4744) 	_setupEvents: function( event ) {
4745) 		var events = {
4746) 			keydown: "_keydown"
4747) 		};
4748) 		if ( event ) {
4749) 			$.each( event.split( " " ), function( index, eventName ) {
4750) 				events[ eventName ] = "_eventHandler";
4751) 			} );
4752) 		}
4753) 
4754) 		this._off( this.headers.add( this.headers.next() ) );
4755) 		this._on( this.headers, events );
4756) 		this._on( this.headers.next(), { keydown: "_panelKeyDown" } );
4757) 		this._hoverable( this.headers );
4758) 		this._focusable( this.headers );

4759) 	},
4760) 

4761) 	_eventHandler: function( event ) {
4762) 		var activeChildren, clickedChildren,
4763) 			options = this.options,
4764) 			active = this.active,
4765) 			clicked = $( event.currentTarget ),
4766) 			clickedIsActive = clicked[ 0 ] === active[ 0 ],
4767) 			collapsing = clickedIsActive && options.collapsible,
4768) 			toShow = collapsing ? $() : clicked.next(),
4769) 			toHide = active.next(),
4770) 			eventData = {
4771) 				oldHeader: active,
4772) 				oldPanel: toHide,
4773) 				newHeader: collapsing ? $() : clicked,
4774) 				newPanel: toShow
4775) 			};

4776) 

4777) 		event.preventDefault();

4778) 

4779) 		if (

4780) 

4781) 				// click on active header, but not collapsible
4782) 				( clickedIsActive && !options.collapsible ) ||
4783) 
4784) 				// allow canceling activation
4785) 				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
4786) 			return;

4787) 		}
4788) 

4789) 		options.active = collapsing ? false : this.headers.index( clicked );

4790) 

4791) 		// When the call to ._toggle() comes after the class changes
4792) 		// it causes a very odd bug in IE 8 (see #6720)
4793) 		this.active = clickedIsActive ? $() : clicked;
4794) 		this._toggle( eventData );

4795) 

4796) 		// Switch classes
4797) 		// corner classes on the previously active header stay after the animation
4798) 		this._removeClass( active, "ui-accordion-header-active", "ui-state-active" );
4799) 		if ( options.icons ) {
4800) 			activeChildren = active.children( ".ui-accordion-header-icon" );
4801) 			this._removeClass( activeChildren, null, options.icons.activeHeader )
4802) 				._addClass( activeChildren, null, options.icons.header );

4803) 		}
4804) 

4805) 		if ( !clickedIsActive ) {
4806) 			this._removeClass( clicked, "ui-accordion-header-collapsed" )
4807) 				._addClass( clicked, "ui-accordion-header-active", "ui-state-active" );
4808) 			if ( options.icons ) {
4809) 				clickedChildren = clicked.children( ".ui-accordion-header-icon" );
4810) 				this._removeClass( clickedChildren, null, options.icons.header )
4811) 					._addClass( clickedChildren, null, options.icons.activeHeader );

4812) 			}

4813) 
4814) 			this._addClass( clicked.next(), "ui-accordion-content-active" );
4815) 		}

4816) 	},
4817) 

4818) 	_toggle: function( data ) {
4819) 		var toShow = data.newPanel,
4820) 			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;

4821) 

4822) 		// Handle activating a panel during the animation for another activation
4823) 		this.prevShow.add( this.prevHide ).stop( true, true );
4824) 		this.prevShow = toShow;
4825) 		this.prevHide = toHide;

4826) 

4827) 		if ( this.options.animate ) {
4828) 			this._animate( toShow, toHide, data );
4829) 		} else {
4830) 			toHide.hide();
4831) 			toShow.show();
4832) 			this._toggleComplete( data );

4833) 		}
4834) 

4835) 		toHide.attr( {
4836) 			"aria-hidden": "true"
4837) 		} );
4838) 		toHide.prev().attr( {
4839) 			"aria-selected": "false",
4840) 			"aria-expanded": "false"
4841) 		} );

4842) 

4843) 		// if we're switching panels, remove the old header from the tab order
4844) 		// if we're opening from collapsed state, remove the previous header from the tab order
4845) 		// if we're collapsing, then keep the collapsing header in the tab order
4846) 		if ( toShow.length && toHide.length ) {
4847) 			toHide.prev().attr( {
4848) 				"tabIndex": -1,
4849) 				"aria-expanded": "false"
4850) 			} );
4851) 		} else if ( toShow.length ) {
4852) 			this.headers.filter( function() {
4853) 				return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
4854) 			} )
4855) 				.attr( "tabIndex", -1 );
4856) 		}

4857) 

4858) 		toShow
4859) 			.attr( "aria-hidden", "false" )
4860) 			.prev()
4861) 				.attr( {
4862) 					"aria-selected": "true",
4863) 					"aria-expanded": "true",
4864) 					tabIndex: 0
4865) 				} );

4866) 	},
4867) 

4868) 	_animate: function( toShow, toHide, data ) {
4869) 		var total, easing, duration,
4870) 			that = this,
4871) 			adjust = 0,
4872) 			boxSizing = toShow.css( "box-sizing" ),
4873) 			down = toShow.length &&
4874) 				( !toHide.length || ( toShow.index() < toHide.index() ) ),
4875) 			animate = this.options.animate || {},
4876) 			options = down && animate.down || animate,
4877) 			complete = function() {
4878) 				that._toggleComplete( data );
4879) 			};

4880) 

4881) 		if ( typeof options === "number" ) {
4882) 			duration = options;
4883) 		}
4884) 		if ( typeof options === "string" ) {
4885) 			easing = options;

4886) 		}
4887) 

4888) 		// fall back from options to animation in case of partial down settings
4889) 		easing = easing || options.easing || animate.easing;
4890) 		duration = duration || options.duration || animate.duration;

4891) 

4892) 		if ( !toHide.length ) {
4893) 			return toShow.animate( this.showProps, duration, easing, complete );
4894) 		}
4895) 		if ( !toShow.length ) {
4896) 			return toHide.animate( this.hideProps, duration, easing, complete );

4897) 		}
4898) 

4899) 		total = toShow.show().outerHeight();
4900) 		toHide.animate( this.hideProps, {
4901) 			duration: duration,
4902) 			easing: easing,
4903) 			step: function( now, fx ) {
4904) 				fx.now = Math.round( now );
4905) 			}
4906) 		} );
4907) 		toShow
4908) 			.hide()
4909) 			.animate( this.showProps, {
4910) 				duration: duration,
4911) 				easing: easing,
4912) 				complete: complete,
4913) 				step: function( now, fx ) {
4914) 					fx.now = Math.round( now );
4915) 					if ( fx.prop !== "height" ) {
4916) 						if ( boxSizing === "content-box" ) {
4917) 							adjust += fx.now;
4918) 						}
4919) 					} else if ( that.options.heightStyle !== "content" ) {
4920) 						fx.now = Math.round( total - toHide.outerHeight() - adjust );
4921) 						adjust = 0;
4922) 					}
4923) 				}
4924) 			} );

4925) 	},
4926) 

4927) 	_toggleComplete: function( data ) {
4928) 		var toHide = data.oldPanel,
4929) 			prev = toHide.prev();

4930) 

4931) 		this._removeClass( toHide, "ui-accordion-content-active" );
4932) 		this._removeClass( prev, "ui-accordion-header-active" )
4933) 			._addClass( prev, "ui-accordion-header-collapsed" );

4934) 

4935) 		// Work around for rendering bug in IE (#5421)
4936) 		if ( toHide.length ) {
4937) 			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;

4938) 		}

4939) 		this._trigger( "activate", null, data );

4940) 	}

4941) } );

4942) 

4943) 
4944) 
4945) var safeActiveElement = $.ui.safeActiveElement = function( document ) {
4946) 	var activeElement;
4947) 
4948) 	// Support: IE 9 only
4949) 	// IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
4950) 	try {
4951) 		activeElement = document.activeElement;
4952) 	} catch ( error ) {
4953) 		activeElement = document.body;

4954) 	}
4955) 

4956) 	// Support: IE 9 - 11 only
4957) 	// IE may return null instead of an element
4958) 	// Interestingly, this only seems to occur when NOT in an iframe
4959) 	if ( !activeElement ) {
4960) 		activeElement = document.body;
4961) 	}

4962) 

4963) 	// Support: IE 11 only
4964) 	// IE11 returns a seemingly empty object in some cases when accessing
4965) 	// document.activeElement from an <iframe>
4966) 	if ( !activeElement.nodeName ) {
4967) 		activeElement = document.body;

4968) 	}
4969) 

4970) 	return activeElement;
4971) };

4972) 
4973) 
4974) /*!

4975)  * jQuery UI Menu 1.13.2

4976)  * http://jqueryui.com
4977)  *
4978)  * Copyright jQuery Foundation and other contributors
4979)  * Released under the MIT license.
4980)  * http://jquery.org/license
4981)  */
4982) 

4983) //>>label: Menu
4984) //>>group: Widgets
4985) //>>description: Creates nestable menus.
4986) //>>docs: http://api.jqueryui.com/menu/
4987) //>>demos: http://jqueryui.com/menu/
4988) //>>css.structure: ../../themes/base/core.css
4989) //>>css.structure: ../../themes/base/menu.css
4990) //>>css.theme: ../../themes/base/theme.css

4991) 
4992) 

4993) var widgetsMenu = $.widget( "ui.menu", {
4994) 	version: "1.13.2",
4995) 	defaultElement: "<ul>",
4996) 	delay: 300,

4997) 	options: {
4998) 		icons: {

4999) 			submenu: "ui-icon-caret-1-e"
5000) 		},
5001) 		items: "> *",
5002) 		menus: "ul",
5003) 		position: {
5004) 			my: "left top",
5005) 			at: "right top"
5006) 		},
5007) 		role: "menu",
5008) 
5009) 		// Callbacks
5010) 		blur: null,
5011) 		focus: null,
5012) 		select: null

5013) 	},

5014) 

5015) 	_create: function() {

5016) 		this.activeMenu = this.element;

5017) 

5018) 		// Flag used to prevent firing of the click handler
5019) 		// as the event bubbles up through nested menus
5020) 		this.mouseHandled = false;
5021) 		this.lastMousePosition = { x: null, y: null };
5022) 		this.element
5023) 			.uniqueId()
5024) 			.attr( {
5025) 				role: this.options.role,
5026) 				tabIndex: 0
5027) 			} );

5028) 

5029) 		this._addClass( "ui-menu", "ui-widget ui-widget-content" );
5030) 		this._on( {

5031) 

5032) 			// Prevent focus from sticking to links inside menu after clicking
5033) 			// them (focus should always stay on UL during navigation).
5034) 			"mousedown .ui-menu-item": function( event ) {
5035) 				event.preventDefault();

5036) 

5037) 				this._activateItem( event );
5038) 			},
5039) 			"click .ui-menu-item": function( event ) {
5040) 				var target = $( event.target );
5041) 				var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
5042) 				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
5043) 					this.select( event );

5044) 

5045) 					// Only set the mouseHandled flag if the event will bubble, see #9469.
5046) 					if ( !event.isPropagationStopped() ) {
5047) 						this.mouseHandled = true;
5048) 					}

5049) 

5050) 					// Open submenu on click
5051) 					if ( target.has( ".ui-menu" ).length ) {
5052) 						this.expand( event );
5053) 					} else if ( !this.element.is( ":focus" ) &&
5054) 							active.closest( ".ui-menu" ).length ) {

5055) 

5056) 						// Redirect focus to the menu
5057) 						this.element.trigger( "focus", [ true ] );
5058) 
5059) 						// If the active item is on the top level, let it stay active.
5060) 						// Otherwise, blur the active item since it is no longer visible.
5061) 						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
5062) 							clearTimeout( this.timer );
5063) 						}
5064) 					}
5065) 				}

5066) 			},

5067) 			"mouseenter .ui-menu-item": "_activateItem",
5068) 			"mousemove .ui-menu-item": "_activateItem",
5069) 			mouseleave: "collapseAll",
5070) 			"mouseleave .ui-menu": "collapseAll",
5071) 			focus: function( event, keepActiveItem ) {

5072) 

5073) 				// If there's already an active item, keep it active
5074) 				// If not, activate the first item
5075) 				var item = this.active || this._menuItems().first();

5076) 

5077) 				if ( !keepActiveItem ) {
5078) 					this.focus( event, item );

5079) 				}

5080) 			},
5081) 			blur: function( event ) {
5082) 				this._delay( function() {
5083) 					var notContained = !$.contains(
5084) 						this.element[ 0 ],
5085) 						$.ui.safeActiveElement( this.document[ 0 ] )
5086) 					);
5087) 					if ( notContained ) {
5088) 						this.collapseAll( event );

5089) 					}

5090) 				} );
5091) 			},
5092) 			keydown: "_keydown"
5093) 		} );

5094) 

5095) 		this.refresh();

5096) 

5097) 		// Clicks outside of a menu collapse any open menus
5098) 		this._on( this.document, {
5099) 			click: function( event ) {
5100) 				if ( this._closeOnDocumentClick( event ) ) {
5101) 					this.collapseAll( event, true );

5102) 				}
5103) 

5104) 				// Reset the mouseHandled flag
5105) 				this.mouseHandled = false;

5106) 			}

5107) 		} );

5108) 	},
5109) 

5110) 	_activateItem: function( event ) {

5111) 

5112) 		// Ignore mouse events while typeahead is active, see #10458.
5113) 		// Prevents focusing the wrong item when typeahead causes a scroll while the mouse
5114) 		// is over an item in the menu
5115) 		if ( this.previousFilter ) {

5116) 			return;
5117) 		}
5118) 

5119) 		// If the mouse didn't actually move, but the page was scrolled, ignore the event (#9356)
5120) 		if ( event.clientX === this.lastMousePosition.x &&
5121) 				event.clientY === this.lastMousePosition.y ) {

5122) 			return;
5123) 		}
5124) 

5125) 		this.lastMousePosition = {
5126) 			x: event.clientX,
5127) 			y: event.clientY
5128) 		};

5129) 

5130) 		var actualTarget = $( event.target ).closest( ".ui-menu-item" ),
5131) 			target = $( event.currentTarget );

5132) 

5133) 		// Ignore bubbled events on parent items, see #11641
5134) 		if ( actualTarget[ 0 ] !== target[ 0 ] ) {
5135) 			return;

5136) 		}
5137) 

5138) 		// If the item is already active, there's nothing to do
5139) 		if ( target.is( ".ui-state-active" ) ) {
5140) 			return;

5141) 		}
5142) 

5143) 		// Remove ui-state-active class from siblings of the newly focused menu item
5144) 		// to avoid a jump caused by adjacent elements both having a class with a border
5145) 		this._removeClass( target.siblings().children( ".ui-state-active" ),
5146) 			null, "ui-state-active" );
5147) 		this.focus( event, target );

5148) 	},
5149) 
5150) 	_destroy: function() {

5151) 		var items = this.element.find( ".ui-menu-item" )
5152) 				.removeAttr( "role aria-disabled" ),
5153) 			submenus = items.children( ".ui-menu-item-wrapper" )
5154) 				.removeUniqueId()
5155) 				.removeAttr( "tabIndex role aria-haspopup" );

5156) 

5157) 		// Destroy (sub)menus
5158) 		this.element
5159) 			.removeAttr( "aria-activedescendant" )
5160) 			.find( ".ui-menu" ).addBack()
5161) 				.removeAttr( "role aria-labelledby aria-expanded aria-hidden aria-disabled " +
5162) 					"tabIndex" )
5163) 				.removeUniqueId()
5164) 				.show();

5165) 

5166) 		submenus.children().each( function() {
5167) 			var elem = $( this );
5168) 			if ( elem.data( "ui-menu-submenu-caret" ) ) {
5169) 				elem.remove();
5170) 			}
5171) 		} );
5172) 	},

5173) 

5174) 	_keydown: function( event ) {
5175) 		var match, prev, character, skip,
5176) 			preventDefault = true;

5177) 

5178) 		switch ( event.keyCode ) {
5179) 		case $.ui.keyCode.PAGE_UP:
5180) 			this.previousPage( event );
5181) 			break;
5182) 		case $.ui.keyCode.PAGE_DOWN:
5183) 			this.nextPage( event );
5184) 			break;
5185) 		case $.ui.keyCode.HOME:
5186) 			this._move( "first", "first", event );
5187) 			break;
5188) 		case $.ui.keyCode.END:
5189) 			this._move( "last", "last", event );
5190) 			break;
5191) 		case $.ui.keyCode.UP:
5192) 			this.previous( event );
5193) 			break;
5194) 		case $.ui.keyCode.DOWN:
5195) 			this.next( event );
5196) 			break;
5197) 		case $.ui.keyCode.LEFT:
5198) 			this.collapse( event );
5199) 			break;
5200) 		case $.ui.keyCode.RIGHT:
5201) 			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
5202) 				this.expand( event );
5203) 			}
5204) 			break;
5205) 		case $.ui.keyCode.ENTER:
5206) 		case $.ui.keyCode.SPACE:
5207) 			this._activate( event );
5208) 			break;
5209) 		case $.ui.keyCode.ESCAPE:
5210) 			this.collapse( event );
5211) 			break;
5212) 		default:
5213) 			preventDefault = false;
5214) 			prev = this.previousFilter || "";
5215) 			skip = false;

5216) 

5217) 			// Support number pad values
5218) 			character = event.keyCode >= 96 && event.keyCode <= 105 ?
5219) 				( event.keyCode - 96 ).toString() : String.fromCharCode( event.keyCode );

5220) 

5221) 			clearTimeout( this.filterTimer );

5222) 

5223) 			if ( character === prev ) {
5224) 				skip = true;
5225) 			} else {
5226) 				character = prev + character;

5227) 			}
5228) 

5229) 			match = this._filterMenuItems( character );
5230) 			match = skip && match.index( this.active.next() ) !== -1 ?
5231) 				this.active.nextAll( ".ui-menu-item" ) :
5232) 				match;

5233) 

5234) 			// If no matches on the current filter, reset to the last character pressed
5235) 			// to move down the menu to the first item that starts with that character
5236) 			if ( !match.length ) {
5237) 				character = String.fromCharCode( event.keyCode );
5238) 				match = this._filterMenuItems( character );
5239) 			}

5240) 

5241) 			if ( match.length ) {
5242) 				this.focus( event, match );
5243) 				this.previousFilter = character;
5244) 				this.filterTimer = this._delay( function() {
5245) 					delete this.previousFilter;
5246) 				}, 1000 );
5247) 			} else {
5248) 				delete this.previousFilter;
5249) 			}
5250) 		}

5251) 

5252) 		if ( preventDefault ) {
5253) 			event.preventDefault();
5254) 		}

5255) 	},
5256) 

5257) 	_activate: function( event ) {
5258) 		if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
5259) 			if ( this.active.children( "[aria-haspopup='true']" ).length ) {
5260) 				this.expand( event );
5261) 			} else {
5262) 				this.select( event );
5263) 			}
5264) 		}

5265) 	},
5266) 

5267) 	refresh: function() {
5268) 		var menus, items, newSubmenus, newItems, newWrappers,
5269) 			that = this,
5270) 			icon = this.options.icons.submenu,
5271) 			submenus = this.element.find( this.options.menus );
5272) 
5273) 		this._toggleClass( "ui-menu-icons", null, !!this.element.find( ".ui-icon" ).length );
5274) 
5275) 		// Initialize nested menus
5276) 		newSubmenus = submenus.filter( ":not(.ui-menu)" )
5277) 			.hide()
5278) 			.attr( {
5279) 				role: this.options.role,
5280) 				"aria-hidden": "true",
5281) 				"aria-expanded": "false"
5282) 			} )
5283) 			.each( function() {
5284) 				var menu = $( this ),
5285) 					item = menu.prev(),
5286) 					submenuCaret = $( "<span>" ).data( "ui-menu-submenu-caret", true );
5287) 
5288) 				that._addClass( submenuCaret, "ui-menu-icon", "ui-icon " + icon );
5289) 				item
5290) 					.attr( "aria-haspopup", "true" )
5291) 					.prepend( submenuCaret );
5292) 				menu.attr( "aria-labelledby", item.attr( "id" ) );
5293) 			} );
5294) 
5295) 		this._addClass( newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front" );
5296) 
5297) 		menus = submenus.add( this.element );
5298) 		items = menus.find( this.options.items );
5299) 
5300) 		// Initialize menu-items containing spaces and/or dashes only as dividers
5301) 		items.not( ".ui-menu-item" ).each( function() {
5302) 			var item = $( this );
5303) 			if ( that._isDivider( item ) ) {
5304) 				that._addClass( item, "ui-menu-divider", "ui-widget-content" );
5305) 			}
5306) 		} );
5307) 
5308) 		// Don't refresh list items that are already adapted
5309) 		newItems = items.not( ".ui-menu-item, .ui-menu-divider" );
5310) 		newWrappers = newItems.children()
5311) 			.not( ".ui-menu" )
5312) 				.uniqueId()
5313) 				.attr( {
5314) 					tabIndex: -1,
5315) 					role: this._itemRole()
5316) 				} );
5317) 		this._addClass( newItems, "ui-menu-item" )
5318) 			._addClass( newWrappers, "ui-menu-item-wrapper" );
5319) 
5320) 		// Add aria-disabled attribute to any disabled menu item
5321) 		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
5322) 
5323) 		// If the active item has been removed, blur the menu
5324) 		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
5325) 			this.blur();

5326) 		}
5327) 	},
5328) 

5329) 	_itemRole: function() {
5330) 		return {
5331) 			menu: "menuitem",
5332) 			listbox: "option"
5333) 		}[ this.options.role ];

5334) 	},
5335) 

5336) 	_setOption: function( key, value ) {
5337) 		if ( key === "icons" ) {
5338) 			var icons = this.element.find( ".ui-menu-icon" );
5339) 			this._removeClass( icons, null, this.options.icons.submenu )
5340) 				._addClass( icons, null, value.submenu );

5341) 		}

5342) 		this._super( key, value );

5343) 	},
5344) 

5345) 	_setOptionDisabled: function( value ) {
5346) 		this._super( value );

5347) 

5348) 		this.element.attr( "aria-disabled", String( value ) );
5349) 		this._toggleClass( null, "ui-state-disabled", !!value );
5350) 	},
5351) 
5352) 	focus: function( event, item ) {
5353) 		var nested, focused, activeParent;
5354) 		this.blur( event, event && event.type === "focus" );
5355) 
5356) 		this._scrollIntoView( item );
5357) 
5358) 		this.active = item.first();
5359) 
5360) 		focused = this.active.children( ".ui-menu-item-wrapper" );
5361) 		this._addClass( focused, null, "ui-state-active" );
5362) 
5363) 		// Only update aria-activedescendant if there's a role
5364) 		// otherwise we assume focus is managed elsewhere
5365) 		if ( this.options.role ) {
5366) 			this.element.attr( "aria-activedescendant", focused.attr( "id" ) );

5367) 		}
5368) 

5369) 		// Highlight active parent menu item, if any
5370) 		activeParent = this.active
5371) 			.parent()
5372) 				.closest( ".ui-menu-item" )
5373) 					.children( ".ui-menu-item-wrapper" );
5374) 		this._addClass( activeParent, null, "ui-state-active" );

5375) 

5376) 		if ( event && event.type === "keydown" ) {
5377) 			this._close();
5378) 		} else {
5379) 			this.timer = this._delay( function() {
5380) 				this._close();
5381) 			}, this.delay );

5382) 		}
5383) 

5384) 		nested = item.children( ".ui-menu" );
5385) 		if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
5386) 			this._startOpening( nested );

5387) 		}

5388) 		this.activeMenu = item.parent();
5389) 
5390) 		this._trigger( "focus", event, { item: item } );

5391) 	},
5392) 

5393) 	_scrollIntoView: function( item ) {
5394) 		var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
5395) 		if ( this._hasScroll() ) {
5396) 			borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0;
5397) 			paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0;
5398) 			offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
5399) 			scroll = this.activeMenu.scrollTop();
5400) 			elementHeight = this.activeMenu.height();
5401) 			itemHeight = item.outerHeight();

5402) 

5403) 			if ( offset < 0 ) {
5404) 				this.activeMenu.scrollTop( scroll + offset );
5405) 			} else if ( offset + itemHeight > elementHeight ) {
5406) 				this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );

5407) 			}
5408) 		}
5409) 	},
5410) 

5411) 	blur: function( event, fromFocus ) {
5412) 		if ( !fromFocus ) {
5413) 			clearTimeout( this.timer );
5414) 		}
5415) 
5416) 		if ( !this.active ) {

5417) 			return;
5418) 		}

5419) 
5420) 		this._removeClass( this.active.children( ".ui-menu-item-wrapper" ),
5421) 			null, "ui-state-active" );
5422) 
5423) 		this._trigger( "blur", event, { item: this.active } );
5424) 		this.active = null;
5425) 	},
5426) 
5427) 	_startOpening: function( submenu ) {
5428) 		clearTimeout( this.timer );
5429) 
5430) 		// Don't open if already open fixes a Firefox bug that caused a .5 pixel
5431) 		// shift in the submenu position when mousing over the caret icon
5432) 		if ( submenu.attr( "aria-hidden" ) !== "true" ) {
5433) 			return;

5434) 		}

5435) 
5436) 		this.timer = this._delay( function() {
5437) 			this._close();
5438) 			this._open( submenu );
5439) 		}, this.delay );

5440) 	},
5441) 

5442) 	_open: function( submenu ) {
5443) 		var position = $.extend( {
5444) 			of: this.active
5445) 		}, this.options.position );

5446) 

5447) 		clearTimeout( this.timer );
5448) 		this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
5449) 			.hide()
5450) 			.attr( "aria-hidden", "true" );
5451) 
5452) 		submenu
5453) 			.show()
5454) 			.removeAttr( "aria-hidden" )
5455) 			.attr( "aria-expanded", "true" )
5456) 			.position( position );
5457) 	},
5458) 
5459) 	collapseAll: function( event, all ) {
5460) 		clearTimeout( this.timer );
5461) 		this.timer = this._delay( function() {
5462) 
5463) 			// If we were passed an event, look for the submenu that contains the event
5464) 			var currentMenu = all ? this.element :
5465) 				$( event && event.target ).closest( this.element.find( ".ui-menu" ) );
5466) 
5467) 			// If we found no valid submenu ancestor, use the main menu to close all
5468) 			// sub menus anyway
5469) 			if ( !currentMenu.length ) {
5470) 				currentMenu = this.element;
5471) 			}
5472) 
5473) 			this._close( currentMenu );
5474) 
5475) 			this.blur( event );
5476) 
5477) 			// Work around active item staying active after menu is blurred
5478) 			this._removeClass( currentMenu.find( ".ui-state-active" ), null, "ui-state-active" );
5479) 
5480) 			this.activeMenu = currentMenu;
5481) 		}, all ? 0 : this.delay );
5482) 	},
5483) 
5484) 	// With no arguments, closes the currently active menu - if nothing is active
5485) 	// it closes all menus.  If passed an argument, it will search for menus BELOW
5486) 	_close: function( startMenu ) {
5487) 		if ( !startMenu ) {
5488) 			startMenu = this.active ? this.active.parent() : this.element;

5489) 		}
5490) 

5491) 		startMenu.find( ".ui-menu" )
5492) 			.hide()
5493) 			.attr( "aria-hidden", "true" )
5494) 			.attr( "aria-expanded", "false" );
5495) 	},
5496) 
5497) 	_closeOnDocumentClick: function( event ) {
5498) 		return !$( event.target ).closest( ".ui-menu" ).length;
5499) 	},
5500) 
5501) 	_isDivider: function( item ) {
5502) 
5503) 		// Match hyphen, em dash, en dash
5504) 		return !/[^\-\u2014\u2013\s]/.test( item.text() );
5505) 	},
5506) 
5507) 	collapse: function( event ) {
5508) 		var newItem = this.active &&
5509) 			this.active.parent().closest( ".ui-menu-item", this.element );
5510) 		if ( newItem && newItem.length ) {
5511) 			this._close();
5512) 			this.focus( event, newItem );

5513) 		}

5514) 	},

5515) 

5516) 	expand: function( event ) {
5517) 		var newItem = this.active && this._menuItems( this.active.children( ".ui-menu" ) ).first();
5518) 
5519) 		if ( newItem && newItem.length ) {
5520) 			this._open( newItem.parent() );
5521) 
5522) 			// Delay so Firefox will not hide activedescendant change in expanding submenu from AT
5523) 			this._delay( function() {
5524) 				this.focus( event, newItem );
5525) 			} );

5526) 		}
5527) 	},
5528) 

5529) 	next: function( event ) {
5530) 		this._move( "next", "first", event );
5531) 	},

5532) 

5533) 	previous: function( event ) {
5534) 		this._move( "prev", "last", event );
5535) 	},

5536) 

5537) 	isFirstItem: function() {
5538) 		return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
5539) 	},

5540) 

5541) 	isLastItem: function() {
5542) 		return this.active && !this.active.nextAll( ".ui-menu-item" ).length;

5543) 	},
5544) 

5545) 	_menuItems: function( menu ) {
5546) 		return ( menu || this.element )
5547) 			.find( this.options.items )
5548) 			.filter( ".ui-menu-item" );
5549) 	},

5550) 

5551) 	_move: function( direction, filter, event ) {
5552) 		var next;
5553) 		if ( this.active ) {
5554) 			if ( direction === "first" || direction === "last" ) {
5555) 				next = this.active
5556) 					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
5557) 					.last();
5558) 			} else {
5559) 				next = this.active
5560) 					[ direction + "All" ]( ".ui-menu-item" )
5561) 					.first();
5562) 			}

5563) 		}

5564) 		if ( !next || !next.length || !this.active ) {
5565) 			next = this._menuItems( this.activeMenu )[ filter ]();

5566) 		}

5567) 
5568) 		this.focus( event, next );

5569) 	},
5570) 

5571) 	nextPage: function( event ) {
5572) 		var item, base, height;

5573) 

5574) 		if ( !this.active ) {
5575) 			this.next( event );

5576) 			return;
5577) 		}

5578) 		if ( this.isLastItem() ) {
5579) 			return;

5580) 		}

5581) 		if ( this._hasScroll() ) {
5582) 			base = this.active.offset().top;
5583) 			height = this.element.innerHeight();

5584) 

5585) 			// jQuery 3.2 doesn't include scrollbars in innerHeight, add it back.
5586) 			if ( $.fn.jquery.indexOf( "3.2." ) === 0 ) {
5587) 				height += this.element[ 0 ].offsetHeight - this.element.outerHeight();

5588) 			}
5589) 

5590) 			this.active.nextAll( ".ui-menu-item" ).each( function() {
5591) 				item = $( this );
5592) 				return item.offset().top - base - height < 0;
5593) 			} );
5594) 
5595) 			this.focus( event, item );
5596) 		} else {
5597) 			this.focus( event, this._menuItems( this.activeMenu )
5598) 				[ !this.active ? "first" : "last" ]() );

5599) 		}
5600) 	},
5601) 

5602) 	previousPage: function( event ) {
5603) 		var item, base, height;
5604) 		if ( !this.active ) {
5605) 			this.next( event );
5606) 			return;

5607) 		}

5608) 		if ( this.isFirstItem() ) {
5609) 			return;

5610) 		}

5611) 		if ( this._hasScroll() ) {
5612) 			base = this.active.offset().top;
5613) 			height = this.element.innerHeight();

5614) 

5615) 			// jQuery 3.2 doesn't include scrollbars in innerHeight, add it back.
5616) 			if ( $.fn.jquery.indexOf( "3.2." ) === 0 ) {
5617) 				height += this.element[ 0 ].offsetHeight - this.element.outerHeight();

5618) 			}
5619) 

5620) 			this.active.prevAll( ".ui-menu-item" ).each( function() {
5621) 				item = $( this );
5622) 				return item.offset().top - base + height > 0;
5623) 			} );
5624) 
5625) 			this.focus( event, item );
5626) 		} else {
5627) 			this.focus( event, this._menuItems( this.activeMenu ).first() );

5628) 		}
5629) 	},
5630) 

5631) 	_hasScroll: function() {
5632) 		return this.element.outerHeight() < this.element.prop( "scrollHeight" );

5633) 	},
5634) 

5635) 	select: function( event ) {

5636) 

5637) 		// TODO: It should never be possible to not have an active item at this
5638) 		// point, but the tests don't trigger mouseenter before click.
5639) 		this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
5640) 		var ui = { item: this.active };
5641) 		if ( !this.active.has( ".ui-menu" ).length ) {
5642) 			this.collapseAll( event, true );

5643) 		}

5644) 		this._trigger( "select", event, ui );

5645) 	},
5646) 

5647) 	_filterMenuItems: function( character ) {
5648) 		var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
5649) 			regex = new RegExp( "^" + escapedCharacter, "i" );

5650) 

5651) 		return this.activeMenu
5652) 			.find( this.options.items )

5653) 

5654) 				// Only match on items, not dividers or other content (#10571)
5655) 				.filter( ".ui-menu-item" )
5656) 					.filter( function() {
5657) 						return regex.test(
5658) 							String.prototype.trim.call(
5659) 								$( this ).children( ".ui-menu-item-wrapper" ).text() ) );
5660) 					} );
5661) 	}
5662) } );

5663) 
5664) 

5665) /*!
5666)  * jQuery UI Autocomplete 1.13.2
5667)  * http://jqueryui.com
5668)  *
5669)  * Copyright jQuery Foundation and other contributors
5670)  * Released under the MIT license.
5671)  * http://jquery.org/license
5672)  */

5673) 

5674) //>>label: Autocomplete
5675) //>>group: Widgets
5676) //>>description: Lists suggested words as the user is typing.
5677) //>>docs: http://api.jqueryui.com/autocomplete/
5678) //>>demos: http://jqueryui.com/autocomplete/
5679) //>>css.structure: ../../themes/base/core.css
5680) //>>css.structure: ../../themes/base/autocomplete.css
5681) //>>css.theme: ../../themes/base/theme.css

5682) 
5683) 

5684) $.widget( "ui.autocomplete", {
5685) 	version: "1.13.2",
5686) 	defaultElement: "<input>",
5687) 	options: {
5688) 		appendTo: null,
5689) 		autoFocus: false,
5690) 		delay: 300,
5691) 		minLength: 1,
5692) 		position: {
5693) 			my: "left top",
5694) 			at: "left bottom",
5695) 			collision: "none"
5696) 		},
5697) 		source: null,

5698) 

5699) 		// Callbacks
5700) 		change: null,
5701) 		close: null,
5702) 		focus: null,
5703) 		open: null,
5704) 		response: null,
5705) 		search: null,
5706) 		select: null

5707) 	},
5708) 

5709) 	requestIndex: 0,
5710) 	pending: 0,
5711) 	liveRegionTimer: null,

5712) 

5713) 	_create: function() {
5714) 
5715) 		// Some browsers only repeat keydown events, not keypress events,
5716) 		// so we use the suppressKeyPress flag to determine if we've already
5717) 		// handled the keydown event. #7269
5718) 		// Unfortunately the code for & in keypress is the same as the up arrow,
5719) 		// so we use the suppressKeyPressRepeat flag to avoid handling keypress
5720) 		// events when we know the keydown event was used to modify the
5721) 		// search term. #7799
5722) 		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
5723) 			nodeName = this.element[ 0 ].nodeName.toLowerCase(),
5724) 			isTextarea = nodeName === "textarea",
5725) 			isInput = nodeName === "input";

5726) 

5727) 		// Textareas are always multi-line
5728) 		// Inputs are always single-line, even if inside a contentEditable element
5729) 		// IE also treats inputs as contentEditable
5730) 		// All other element types are determined by whether or not they're contentEditable
5731) 		this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );

5732) 

5733) 		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
5734) 		this.isNewMenu = true;

5735) 

5736) 		this._addClass( "ui-autocomplete-input" );
5737) 		this.element.attr( "autocomplete", "off" );

5738) 

5739) 		this._on( this.element, {
5740) 			keydown: function( event ) {
5741) 				if ( this.element.prop( "readOnly" ) ) {
5742) 					suppressKeyPress = true;
5743) 					suppressInput = true;
5744) 					suppressKeyPressRepeat = true;
5745) 					return;
5746) 				}

5747) 

5748) 				suppressKeyPress = false;
5749) 				suppressInput = false;
5750) 				suppressKeyPressRepeat = false;
5751) 				var keyCode = $.ui.keyCode;
5752) 				switch ( event.keyCode ) {
5753) 				case keyCode.PAGE_UP:
5754) 					suppressKeyPress = true;
5755) 					this._move( "previousPage", event );
5756) 					break;
5757) 				case keyCode.PAGE_DOWN:
5758) 					suppressKeyPress = true;
5759) 					this._move( "nextPage", event );
5760) 					break;
5761) 				case keyCode.UP:
5762) 					suppressKeyPress = true;
5763) 					this._keyEvent( "previous", event );
5764) 					break;
5765) 				case keyCode.DOWN:
5766) 					suppressKeyPress = true;
5767) 					this._keyEvent( "next", event );
5768) 					break;
5769) 				case keyCode.ENTER:

5770) 

5771) 					// when menu is open and has focus
5772) 					if ( this.menu.active ) {

5773) 

5774) 						// #6055 - Opera still allows the keypress to occur
5775) 						// which causes forms to submit
5776) 						suppressKeyPress = true;
5777) 						event.preventDefault();
5778) 						this.menu.select( event );
5779) 					}
5780) 					break;
5781) 				case keyCode.TAB:
5782) 					if ( this.menu.active ) {
5783) 						this.menu.select( event );
5784) 					}
5785) 					break;
5786) 				case keyCode.ESCAPE:
5787) 					if ( this.menu.element.is( ":visible" ) ) {
5788) 						if ( !this.isMultiLine ) {
5789) 							this._value( this.term );
5790) 						}
5791) 						this.close( event );

5792) 

5793) 						// Different browsers have different default behavior for escape
5794) 						// Single press can mean undo or clear
5795) 						// Double press in IE means clear the whole form
5796) 						event.preventDefault();
5797) 					}
5798) 					break;
5799) 				default:
5800) 					suppressKeyPressRepeat = true;

5801) 

5802) 					// search timeout should be triggered before the input value is changed
5803) 					this._searchTimeout( event );
5804) 					break;
5805) 				}
5806) 			},
5807) 			keypress: function( event ) {
5808) 				if ( suppressKeyPress ) {
5809) 					suppressKeyPress = false;
5810) 					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
5811) 						event.preventDefault();
5812) 					}
5813) 					return;
5814) 				}
5815) 				if ( suppressKeyPressRepeat ) {
5816) 					return;
5817) 				}

5818) 

5819) 				// Replicate some key handlers to allow them to repeat in Firefox and Opera
5820) 				var keyCode = $.ui.keyCode;
5821) 				switch ( event.keyCode ) {
5822) 				case keyCode.PAGE_UP:
5823) 					this._move( "previousPage", event );
5824) 					break;
5825) 				case keyCode.PAGE_DOWN:
5826) 					this._move( "nextPage", event );
5827) 					break;
5828) 				case keyCode.UP:
5829) 					this._keyEvent( "previous", event );
5830) 					break;
5831) 				case keyCode.DOWN:
5832) 					this._keyEvent( "next", event );
5833) 					break;
5834) 				}
5835) 			},
5836) 			input: function( event ) {
5837) 				if ( suppressInput ) {
5838) 					suppressInput = false;
5839) 					event.preventDefault();
5840) 					return;
5841) 				}
5842) 				this._searchTimeout( event );
5843) 			},
5844) 			focus: function() {
5845) 				this.selectedItem = null;
5846) 				this.previous = this._value();
5847) 			},
5848) 			blur: function( event ) {
5849) 				clearTimeout( this.searching );
5850) 				this.close( event );
5851) 				this._change( event );

5852) 			}

5853) 		} );

5854) 

5855) 		this._initSource();
5856) 		this.menu = $( "<ul>" )
5857) 			.appendTo( this._appendTo() )
5858) 			.menu( {

5859) 

5860) 				// disable ARIA support, the live region takes care of that
5861) 				role: null
5862) 			} )
5863) 			.hide()

5864) 

5865) 			// Support: IE 11 only, Edge <= 14
5866) 			// For other browsers, we preventDefault() on the mousedown event
5867) 			// to keep the dropdown from taking focus from the input. This doesn't
5868) 			// work for IE/Edge, causing problems with selection and scrolling (#9638)
5869) 			// Happily, IE and Edge support an "unselectable" attribute that
5870) 			// prevents an element from receiving focus, exactly what we want here.
5871) 			.attr( {
5872) 				"unselectable": "on"
5873) 			} )
5874) 			.menu( "instance" );

5875) 

5876) 		this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );
5877) 		this._on( this.menu.element, {
5878) 			mousedown: function( event ) {

5879) 

5880) 				// Prevent moving focus out of the text field
5881) 				event.preventDefault();
5882) 			},
5883) 			menufocus: function( event, ui ) {
5884) 				var label, item;

5885) 

5886) 				// support: Firefox
5887) 				// Prevent accidental activation of menu items in Firefox (#7024 #9118)
5888) 				if ( this.isNewMenu ) {
5889) 					this.isNewMenu = false;
5890) 					if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
5891) 						this.menu.blur();