https://steveescoffery.com/about/

64

79<script type="text/javascript">
80jQuery(document).ready(function($) {
81
82/*! jQuery UI - v1.12.1 - 2016-10-29
83* http://jqueryui.com
84* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/draggable.js, widgets/resizable.js, widgets/accordion.js, widgets/autocomplete.js, widgets/button.js, widgets/checkboxradio.js, widgets/controlgroup.js, widgets/datepicker.js, widgets/dialog.js, widgets/menu.js, widgets/mouse.js, widgets/progressbar.js, widgets/selectmenu.js, widgets/slider.js, widgets/spinner.js, widgets/tabs.js, widgets/tooltip.js
85* Copyright jQuery Foundation and other contributors; Licensed MIT */
86
87(function( factory ) {
88	if ( typeof define === "function" && define.amd ) {
89
90		// AMD. Register as an anonymous module.
91		define([ "jquery" ], factory );
92	} else {
93
94		// Browser globals
95		factory( jQuery );
96	}
97}(function( $ ) {
98
99$.ui = $.ui || {};
100
101var version = $.ui.version = "1.12.1";
102
103
104/*!
105 * jQuery UI Widget 1.12.1
106 * http://jqueryui.com
107 *
108 * Copyright jQuery Foundation and other contributors
109 * Released under the MIT license.
110 * http://jquery.org/license
111 */
112
113//>>label: Widget
114//>>group: Core
115//>>description: Provides a factory for creating stateful widgets with a common API.
116//>>docs: http://api.jqueryui.com/jQuery.widget/
117//>>demos: http://jqueryui.com/widget/
118
119
120
121var widgetUuid = 0;
122var widgetSlice = Array.prototype.slice;
123
124$.cleanData = ( function( orig ) {
125	return function( elems ) {
126		var events, elem, i;
127		for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
128			try {
129
130				// Only trigger remove when necessary to save time
131				events = $._data( elem, "events" );
132				if ( events && events.remove ) {
133					$( elem ).triggerHandler( "remove" );
134				}
135
136			// Http://bugs.jquery.com/ticket/8235
137			} catch ( e ) {}
138		}
139		orig( elems );
140	};
141} )( $.cleanData );
142
143$.widget = function( name, base, prototype ) {
144	var existingConstructor, constructor, basePrototype;
145
146	// ProxiedPrototype allows the provided prototype to remain unmodified
147	// so that it can be used as a mixin for multiple widgets (#8876)
148	var proxiedPrototype = {};
149
150	var namespace = name.split( "." )[ 0 ];
151	name = name.split( "." )[ 1 ];
152	var fullName = namespace + "-" + name;
153
154	if ( !prototype ) {
155		prototype = base;
156		base = $.Widget;
157	}
158
159	if ( $.isArray( prototype ) ) {
160		prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
161	}
162
163	// Create selector for plugin
164	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
165		return !!$.data( elem, fullName );
166	};
167
168	$[ namespace ] = $[ namespace ] || {};
169	existingConstructor = $[ namespace ][ name ];
170	constructor = $[ namespace ][ name ] = function( options, element ) {
171
172		// Allow instantiation without "new" keyword
173		if ( !this._createWidget ) {
174			return new constructor( options, element );
175		}
176
177		// Allow instantiation without initializing for simple inheritance
178		// must use "new" keyword (the code above always passes args)
179		if ( arguments.length ) {
180			this._createWidget( options, element );
181		}
182	};
183
184	// Extend with the existing constructor to carry over any static properties
185	$.extend( constructor, existingConstructor, {
186		version: prototype.version,
187
188		// Copy the object used to create the prototype in case we need to
189		// redefine the widget later
190		_proto: $.extend( {}, prototype ),
191
192		// Track widgets that inherit from this widget in case this widget is
193		// redefined after a widget inherits from it
194		_childConstructors: []
195	} );
196
197	basePrototype = new base();
198
199	// We need to make the options hash a property directly on the new instance
200	// otherwise we'll modify the options hash on the prototype that we're
201	// inheriting from
202	basePrototype.options = $.widget.extend( {}, basePrototype.options );
203	$.each( prototype, function( prop, value ) {
204		if ( !$.isFunction( value ) ) {
205			proxiedPrototype[ prop ] = value;
206			return;
207		}
208		proxiedPrototype[ prop ] = ( function() {
209			function _super() {
210				return base.prototype[ prop ].apply( this, arguments );
211			}
212
213			function _superApply( args ) {
214				return base.prototype[ prop ].apply( this, args );
215			}
216
217			return function() {
218				var __super = this._super;
219				var __superApply = this._superApply;
220				var returnValue;
221
222				this._super = _super;
223				this._superApply = _superApply;
224
225				returnValue = value.apply( this, arguments );
226
227				this._super = __super;
228				this._superApply = __superApply;
229
230				return returnValue;
231			};
232		} )();
233	} );
234	constructor.prototype = $.widget.extend( basePrototype, {
235
236		// TODO: remove support for widgetEventPrefix
237		// always use the name + a colon as the prefix, e.g., draggable:start
238		// don't prefix for widgets that aren't DOM-based
239		widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
240	}, proxiedPrototype, {
241		constructor: constructor,
242		namespace: namespace,
243		widgetName: name,
244		widgetFullName: fullName
245	} );
246
247	// If this widget is being redefined then we need to find all widgets that
248	// are inheriting from it and redefine all of them so that they inherit from
249	// the new version of this widget. We're essentially trying to replace one
250	// level in the prototype chain.
251	if ( existingConstructor ) {
252		$.each( existingConstructor._childConstructors, function( i, child ) {
253			var childPrototype = child.prototype;
254
255			// Redefine the child widget using the same prototype that was
256			// originally used, but inherit from the new version of the base
257			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
258				child._proto );
259		} );
260
261		// Remove the list of existing child constructors from the old constructor
262		// so the old child constructors can be garbage collected
263		delete existingConstructor._childConstructors;
264	} else {
265		base._childConstructors.push( constructor );
266	}
267
268	$.widget.bridge( name, constructor );
269
270	return constructor;
271};
272
273$.widget.extend = function( target ) {
274	var input = widgetSlice.call( arguments, 1 );
275	var inputIndex = 0;
276	var inputLength = input.length;
277	var key;
278	var value;
279
280	for ( ; inputIndex < inputLength; inputIndex++ ) {
281		for ( key in input[ inputIndex ] ) {
282			value = input[ inputIndex ][ key ];
283			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
284
285				// Clone objects
286				if ( $.isPlainObject( value ) ) {
287					target[ key ] = $.isPlainObject( target[ key ] ) ?
288						$.widget.extend( {}, target[ key ], value ) :
289
290						// Don't extend strings, arrays, etc. with objects
291						$.widget.extend( {}, value );
292
293				// Copy everything else by reference
294				} else {
295					target[ key ] = value;
296				}
297			}
298		}
299	}
300	return target;
301};
302
303$.widget.bridge = function( name, object ) {
304	var fullName = object.prototype.widgetFullName || name;
305	$.fn[ name ] = function( options ) {
306		var isMethodCall = typeof options === "string";
307		var args = widgetSlice.call( arguments, 1 );
308		var returnValue = this;
309
310		if ( isMethodCall ) {
311
312			// If this is an empty collection, we need to have the instance method
313			// return undefined instead of the jQuery instance
314			if ( !this.length && options === "instance" ) {
315				returnValue = undefined;
316			} else {
317				this.each( function() {
318					var methodValue;
319					var instance = $.data( this, fullName );
320
321					if ( options === "instance" ) {
322						returnValue = instance;
323						return false;
324					}
325
326					if ( !instance ) {
327						return $.error( "cannot call methods on " + name +
328							" prior to initialization; " +
329							"attempted to call method '" + options + "'" );
330					}
331
332					if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) {
333						return $.error( "no such method '" + options + "' for " + name +
334							" widget instance" );
335					}
336
337					methodValue = instance[ options ].apply( instance, args );
338
339					if ( methodValue !== instance && methodValue !== undefined ) {
340						returnValue = methodValue && methodValue.jquery ?
341							returnValue.pushStack( methodValue.get() ) :
342							methodValue;
343						return false;
344					}
345				} );
346			}
347		} else {
348
349			// Allow multiple hashes to be passed on init
350			if ( args.length ) {
351				options = $.widget.extend.apply( null, [ options ].concat( args ) );
352			}
353
354			this.each( function() {
355				var instance = $.data( this, fullName );
356				if ( instance ) {
357					instance.option( options || {} );
358					if ( instance._init ) {
359						instance._init();
360					}
361				} else {
362					$.data( this, fullName, new object( options, this ) );
363				}
364			} );
365		}
366
367		return returnValue;
368	};
369};
370
371$.Widget = function( /* options, element */ ) {};
372$.Widget._childConstructors = [];
373
374$.Widget.prototype = {
375	widgetName: "widget",
376	widgetEventPrefix: "",
377	defaultElement: "<div>",
378
379	options: {
380		classes: {},
381		disabled: false,
382
383		// Callbacks
384		create: null
385	},
386
387	_createWidget: function( options, element ) {
388		element = $( element || this.defaultElement || this )[ 0 ];
389		this.element = $( element );
390		this.uuid = widgetUuid++;
391		this.eventNamespace = "." + this.widgetName + this.uuid;
392
393		this.bindings = $();
394		this.hoverable = $();
395		this.focusable = $();
396		this.classesElementLookup = {};
397
398		if ( element !== this ) {
399			$.data( element, this.widgetFullName, this );
400			this._on( true, this.element, {
401				remove: function( event ) {
402					if ( event.target === element ) {
403						this.destroy();
404					}
405				}
406			} );
407			this.document = $( element.style ?
408
409				// Element within the document
410				element.ownerDocument :
411
412				// Element is window or document
413				element.document || element );
414			this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
415		}
416
417		this.options = $.widget.extend( {},
418			this.options,
419			this._getCreateOptions(),
420			options );
421
422		this._create();
423
424		if ( this.options.disabled ) {
425			this._setOptionDisabled( this.options.disabled );
426		}
427
428		this._trigger( "create", null, this._getCreateEventData() );
429		this._init();
430	},
431
432	_getCreateOptions: function() {
433		return {};
434	},
435
436	_getCreateEventData: $.noop,
437
438	_create: $.noop,
439
440	_init: $.noop,
441
442	destroy: function() {
443		var that = this;
444
445		this._destroy();
446		$.each( this.classesElementLookup, function( key, value ) {
447			that._removeClass( value, key );
448		} );
449
450		// We can probably remove the unbind calls in 2.0
451		// all event bindings should go through this._on()
452		this.element
453			.off( this.eventNamespace )
454			.removeData( this.widgetFullName );
455		this.widget()
456			.off( this.eventNamespace )
457			.removeAttr( "aria-disabled" );
458
459		// Clean up events and states
460		this.bindings.off( this.eventNamespace );
461	},
462
463	_destroy: $.noop,
464
465	widget: function() {
466		return this.element;
467	},
468
469	option: function( key, value ) {
470		var options = key;
471		var parts;
472		var curOption;
473		var i;
474
475		if ( arguments.length === 0 ) {
476
477			// Don't return a reference to the internal hash
478			return $.widget.extend( {}, this.options );
479		}
480
481		if ( typeof key === "string" ) {
482
483			// Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
484			options = {};
485			parts = key.split( "." );
486			key = parts.shift();
487			if ( parts.length ) {
488				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
489				for ( i = 0; i < parts.length - 1; i++ ) {
490					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
491					curOption = curOption[ parts[ i ] ];
492				}
493				key = parts.pop();
494				if ( arguments.length === 1 ) {
495					return curOption[ key ] === undefined ? null : curOption[ key ];
496				}
497				curOption[ key ] = value;
498			} else {
499				if ( arguments.length === 1 ) {
500					return this.options[ key ] === undefined ? null : this.options[ key ];
501				}
502				options[ key ] = value;
503			}
504		}
505
506		this._setOptions( options );
507
508		return this;
509	},
510
511	_setOptions: function( options ) {
512		var key;
513
514		for ( key in options ) {
515			this._setOption( key, options[ key ] );
516		}
517
518		return this;
519	},
520
521	_setOption: function( key, value ) {
522		if ( key === "classes" ) {
523			this._setOptionClasses( value );
524		}
525
526		this.options[ key ] = value;
527
528		if ( key === "disabled" ) {
529			this._setOptionDisabled( value );
530		}
531
532		return this;
533	},
534
535	_setOptionClasses: function( value ) {
536		var classKey, elements, currentElements;
537
538		for ( classKey in value ) {
539			currentElements = this.classesElementLookup[ classKey ];
540			if ( value[ classKey ] === this.options.classes[ classKey ] ||
541					!currentElements ||
542					!currentElements.length ) {
543				continue;
544			}
545
546			// We are doing this to create a new jQuery object because the _removeClass() call
547			// on the next line is going to destroy the reference to the current elements being
548			// tracked. We need to save a copy of this collection so that we can add the new classes
549			// below.
550			elements = $( currentElements.get() );
551			this._removeClass( currentElements, classKey );
552
553			// We don't use _addClass() here, because that uses this.options.classes
554			// for generating the string of classes. We want to use the value passed in from
555			// _setOption(), this is the new value of the classes option which was passed to
556			// _setOption(). We pass this value directly to _classes().
557			elements.addClass( this._classes( {
558				element: elements,
559				keys: classKey,
560				classes: value,
561				add: true
562			} ) );
563		}
564	},
565
566	_setOptionDisabled: function( value ) {
567		this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
568
569		// If the widget is becoming disabled, then nothing is interactive
570		if ( value ) {
571			this._removeClass( this.hoverable, null, "ui-state-hover" );
572			this._removeClass( this.focusable, null, "ui-state-focus" );
573		}
574	},
575
576	enable: function() {
577		return this._setOptions( { disabled: false } );
578	},
579
580	disable: function() {
581		return this._setOptions( { disabled: true } );
582	},
583
584	_classes: function( options ) {
585		var full = [];
586		var that = this;
587
588		options = $.extend( {
589			element: this.element,
590			classes: this.options.classes || {}
591		}, options );
592
593		function processClassString( classes, checkOption ) {
594			var current, i;
595			for ( i = 0; i < classes.length; i++ ) {
596				current = that.classesElementLookup[ classes[ i ] ] || $();
597				if ( options.add ) {
598					current = $( $.unique( current.get().concat( options.element.get() ) ) );
599				} else {
600					current = $( current.not( options.element ).get() );
601				}
602				that.classesElementLookup[ classes[ i ] ] = current;
603				full.push( classes[ i ] );
604				if ( checkOption && options.classes[ classes[ i ] ] ) {
605					full.push( options.classes[ classes[ i ] ] );
606				}
607			}
608		}
609
610		this._on( options.element, {
611			"remove": "_untrackClassesElement"
612		} );
613
614		if ( options.keys ) {
615			processClassString( options.keys.match( /\S+/g ) || [], true );
616		}
617		if ( options.extra ) {
618			processClassString( options.extra.match( /\S+/g ) || [] );
619		}
620
621		return full.join( " " );
622	},
623
624	_untrackClassesElement: function( event ) {
625		var that = this;
626		$.each( that.classesElementLookup, function( key, value ) {
627			if ( $.inArray( event.target, value ) !== -1 ) {
628				that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
629			}
630		} );
631	},
632
633	_removeClass: function( element, keys, extra ) {
634		return this._toggleClass( element, keys, extra, false );
635	},
636
637	_addClass: function( element, keys, extra ) {
638		return this._toggleClass( element, keys, extra, true );
639	},
640
641	_toggleClass: function( element, keys, extra, add ) {
642		add = ( typeof add === "boolean" ) ? add : extra;
643		var shift = ( typeof element === "string" || element === null ),
644			options = {
645				extra: shift ? keys : extra,
646				keys: shift ? element : keys,
647				element: shift ? this.element : element,
648				add: add
649			};
650		options.element.toggleClass( this._classes( options ), add );
651		return this;
652	},
653
654	_on: function( suppressDisabledCheck, element, handlers ) {
655		var delegateElement;
656		var instance = this;
657
658		// No suppressDisabledCheck flag, shuffle arguments
659		if ( typeof suppressDisabledCheck !== "boolean" ) {
660			handlers = element;
661			element = suppressDisabledCheck;
662			suppressDisabledCheck = false;
663		}
664
665		// No element argument, shuffle and use this.element
666		if ( !handlers ) {
667			handlers = element;
668			element = this.element;
669			delegateElement = this.widget();
670		} else {
671			element = delegateElement = $( element );
672			this.bindings = this.bindings.add( element );
673		}
674
675		$.each( handlers, function( event, handler ) {
676			function handlerProxy() {
677
678				// Allow widgets to customize the disabled handling
679				// - disabled as an array instead of boolean
680				// - disabled class as method for disabling individual parts
681				if ( !suppressDisabledCheck &&
682						( instance.options.disabled === true ||
683						$( this ).hasClass( "ui-state-disabled" ) ) ) {
684					return;
685				}
686				return ( typeof handler === "string" ? instance[ handler ] : handler )
687					.apply( instance, arguments );
688			}
689
690			// Copy the guid so direct unbinding works
691			if ( typeof handler !== "string" ) {
692				handlerProxy.guid = handler.guid =
693					handler.guid || handlerProxy.guid || $.guid++;
694			}
695
696			var match = event.match( /^([\w:-]*)\s*(.*)$/ );
697			var eventName = match[ 1 ] + instance.eventNamespace;
698			var selector = match[ 2 ];
699
700			if ( selector ) {
701				delegateElement.on( eventName, selector, handlerProxy );
702			} else {
703				element.on( eventName, handlerProxy );
704			}
705		} );
706	},
707
708	_off: function( element, eventName ) {
709		eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
710			this.eventNamespace;
711		element.off( eventName ).off( eventName );
712
713		// Clear the stack to avoid memory leaks (#10056)
714		this.bindings = $( this.bindings.not( element ).get() );
715		this.focusable = $( this.focusable.not( element ).get() );
716		this.hoverable = $( this.hoverable.not( element ).get() );
717	},
718
719	_delay: function( handler, delay ) {
720		function handlerProxy() {
721			return ( typeof handler === "string" ? instance[ handler ] : handler )
722				.apply( instance, arguments );
723		}
724		var instance = this;
725		return setTimeout( handlerProxy, delay || 0 );
726	},
727
728	_hoverable: function( element ) {
729		this.hoverable = this.hoverable.add( element );
730		this._on( element, {
731			mouseenter: function( event ) {
732				this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
733			},
734			mouseleave: function( event ) {
735				this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
736			}
737		} );
738	},
739
740	_focusable: function( element ) {
741		this.focusable = this.focusable.add( element );
742		this._on( element, {
743			focusin: function( event ) {
744				this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
745			},
746			focusout: function( event ) {
747				this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
748			}
749		} );
750	},
751
752	_trigger: function( type, event, data ) {
753		var prop, orig;
754		var callback = this.options[ type ];
755
756		data = data || {};
757		event = $.Event( event );
758		event.type = ( type === this.widgetEventPrefix ?
759			type :
760			this.widgetEventPrefix + type ).toLowerCase();
761
762		// The original event may come from any element
763		// so we need to reset the target on the new event
764		event.target = this.element[ 0 ];
765
766		// Copy original event properties over to the new event
767		orig = event.originalEvent;
768		if ( orig ) {
769			for ( prop in orig ) {
770				if ( !( prop in event ) ) {
771					event[ prop ] = orig[ prop ];
772				}
773			}
774		}
775
776		this.element.trigger( event, data );
777		return !( $.isFunction( callback ) &&
778			callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
779			event.isDefaultPrevented() );
780	}
781};
782
783$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
784	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
785		if ( typeof options === "string" ) {
786			options = { effect: options };
787		}
788
789		var hasOptions;
790		var effectName = !options ?
791			method :
792			options === true || typeof options === "number" ?
793				defaultEffect :
794				options.effect || defaultEffect;
795
796		options = options || {};
797		if ( typeof options === "number" ) {
798			options = { duration: options };
799		}
800
801		hasOptions = !$.isEmptyObject( options );
802		options.complete = callback;
803
804		if ( options.delay ) {
805			element.delay( options.delay );
806		}
807
808		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
809			element[ method ]( options );
810		} else if ( effectName !== method && element[ effectName ] ) {

811			element[ effectName ]( options.duration, options.easing, callback );
812		} else {
813			element.queue( function( next ) {
814				$( this )[ method ]();
815				if ( callback ) {
816					callback.call( element[ 0 ] );
817				}
818				next();
819			} );
820		}
821	};
822} );
823
824var widget = $.widget;
825
826
827/*!
828 * jQuery UI Position 1.12.1
829 * http://jqueryui.com
830 *
831 * Copyright jQuery Foundation and other contributors
832 * Released under the MIT license.
833 * http://jquery.org/license
834 *
835 * http://api.jqueryui.com/position/
836 */
837
838//>>label: Position
839//>>group: Core
840//>>description: Positions elements relative to other elements.
841//>>docs: http://api.jqueryui.com/position/
842//>>demos: http://jqueryui.com/position/
843
844
845( function() {
846var cachedScrollbarWidth,
847	max = Math.max,
848	abs = Math.abs,
849	rhorizontal = /left|center|right/,
850	rvertical = /top|center|bottom/,
851	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
852	rposition = /^\w+/,
853	rpercent = /%$/,
854	_position = $.fn.position;
855
856function getOffsets( offsets, width, height ) {
857	return [
858		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
859		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
860	];
861}
862
863function parseCss( element, property ) {
864	return parseInt( $.css( element, property ), 10 ) || 0;
865}
866
867function getDimensions( elem ) {
868	var raw = elem[ 0 ];
869	if ( raw.nodeType === 9 ) {
870		return {
871			width: elem.width(),
872			height: elem.height(),
873			offset: { top: 0, left: 0 }
874		};
875	}
876	if ( $.isWindow( raw ) ) {
877		return {
878			width: elem.width(),
879			height: elem.height(),
880			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
881		};
882	}
883	if ( raw.preventDefault ) {
884		return {
885			width: 0,
886			height: 0,
887			offset: { top: raw.pageY, left: raw.pageX }
888		};
889	}
890	return {
891		width: elem.outerWidth(),
892		height: elem.outerHeight(),
893		offset: elem.offset()
894	};
895}
896
897$.position = {
898	scrollbarWidth: function() {
899		if ( cachedScrollbarWidth !== undefined ) {
900			return cachedScrollbarWidth;
901		}
902		var w1, w2,
903			div = $( "<div " +
904				"style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'>" +
905				"<div style='height:100px;width:auto;'></div></div>" ),
906			innerDiv = div.children()[ 0 ];
907
908		$( "body" ).append( div );
909		w1 = innerDiv.offsetWidth;
910		div.css( "overflow", "scroll" );
911
912		w2 = innerDiv.offsetWidth;
913
914		if ( w1 === w2 ) {
915			w2 = div[ 0 ].clientWidth;
916		}
917
918		div.remove();
919
920		return ( cachedScrollbarWidth = w1 - w2 );
921	},
922	getScrollInfo: function( within ) {
923		var overflowX = within.isWindow || within.isDocument ? "" :
924				within.element.css( "overflow-x" ),
925			overflowY = within.isWindow || within.isDocument ? "" :
926				within.element.css( "overflow-y" ),
927			hasOverflowX = overflowX === "scroll" ||
928				( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
929			hasOverflowY = overflowY === "scroll" ||
930				( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
931		return {
932			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
933			height: hasOverflowX ? $.position.scrollbarWidth() : 0
934		};
935	},
936	getWithinInfo: function( element ) {
937		var withinElement = $( element || window ),
938			isWindow = $.isWindow( withinElement[ 0 ] ),
939			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
940			hasOffset = !isWindow && !isDocument;
941		return {
942			element: withinElement,
943			isWindow: isWindow,
944			isDocument: isDocument,
945			offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
946			scrollLeft: withinElement.scrollLeft(),
947			scrollTop: withinElement.scrollTop(),
948			width: withinElement.outerWidth(),
949			height: withinElement.outerHeight()
950		};
951	}
952};
953
954$.fn.position = function( options ) {
955	if ( !options || !options.of ) {
956		return _position.apply( this, arguments );
957	}
958
959	// Make a copy, we don't want to modify arguments
960	options = $.extend( {}, options );
961
962	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
963		target = $( options.of ),
964		within = $.position.getWithinInfo( options.within ),
965		scrollInfo = $.position.getScrollInfo( within ),
966		collision = ( options.collision || "flip" ).split( " " ),
967		offsets = {};
968
969	dimensions = getDimensions( target );
970	if ( target[ 0 ].preventDefault ) {
971
972		// Force left top to allow flipping
973		options.at = "left top";
974	}
975	targetWidth = dimensions.width;
976	targetHeight = dimensions.height;
977	targetOffset = dimensions.offset;
978
979	// Clone to reuse original targetOffset later
980	basePosition = $.extend( {}, targetOffset );
981
982	// Force my and at to have valid horizontal and vertical positions
983	// if a value is missing or invalid, it will be converted to center
984	$.each( [ "my", "at" ], function() {
985		var pos = ( options[ this ] || "" ).split( " " ),
986			horizontalOffset,
987			verticalOffset;
988
989		if ( pos.length === 1 ) {
990			pos = rhorizontal.test( pos[ 0 ] ) ?

991				pos.concat( [ "center" ] ) :
992				rvertical.test( pos[ 0 ] ) ?
993					[ "center" ].concat( pos ) :
994					[ "center", "center" ];
995		}
996		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
997		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
998
999		// Calculate offsets
1000		horizontalOffset = roffset.exec( pos[ 0 ] );
1001		verticalOffset = roffset.exec( pos[ 1 ] );
1002		offsets[ this ] = [
1003			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1004			verticalOffset ? verticalOffset[ 0 ] : 0
1005		];
1006
1007		// Reduce to just the positions without the offsets
1008		options[ this ] = [
1009			rposition.exec( pos[ 0 ] )[ 0 ],
1010			rposition.exec( pos[ 1 ] )[ 0 ]
1011		];
1012	} );
1013
1014	// Normalize collision option
1015	if ( collision.length === 1 ) {
1016		collision[ 1 ] = collision[ 0 ];
1017	}
1018
1019	if ( options.at[ 0 ] === "right" ) {
1020		basePosition.left += targetWidth;
1021	} else if ( options.at[ 0 ] === "center" ) {
1022		basePosition.left += targetWidth / 2;
1023	}
1024
1025	if ( options.at[ 1 ] === "bottom" ) {
1026		basePosition.top += targetHeight;
1027	} else if ( options.at[ 1 ] === "center" ) {
1028		basePosition.top += targetHeight / 2;
1029	}
1030
1031	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1032	basePosition.left += atOffset[ 0 ];
1033	basePosition.top += atOffset[ 1 ];
1034
1035	return this.each( function() {
1036		var collisionPosition, using,
1037			elem = $( this ),
1038			elemWidth = elem.outerWidth(),
1039			elemHeight = elem.outerHeight(),
1040			marginLeft = parseCss( this, "marginLeft" ),
1041			marginTop = parseCss( this, "marginTop" ),
1042			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
1043				scrollInfo.width,
1044			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
1045				scrollInfo.height,
1046			position = $.extend( {}, basePosition ),
1047			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1048
1049		if ( options.my[ 0 ] === "right" ) {
1050			position.left -= elemWidth;
1051		} else if ( options.my[ 0 ] === "center" ) {
1052			position.left -= elemWidth / 2;
1053		}
1054
1055		if ( options.my[ 1 ] === "bottom" ) {
1056			position.top -= elemHeight;
1057		} else if ( options.my[ 1 ] === "center" ) {
1058			position.top -= elemHeight / 2;
1059		}
1060
1061		position.left += myOffset[ 0 ];
1062		position.top += myOffset[ 1 ];
1063
1064		collisionPosition = {
1065			marginLeft: marginLeft,
1066			marginTop: marginTop
1067		};
1068
1069		$.each( [ "left", "top" ], function( i, dir ) {
1070			if ( $.ui.position[ collision[ i ] ] ) {
1071				$.ui.position[ collision[ i ] ][ dir ]( position, {
1072					targetWidth: targetWidth,
1073					targetHeight: targetHeight,
1074					elemWidth: elemWidth,
1075					elemHeight: elemHeight,
1076					collisionPosition: collisionPosition,
1077					collisionWidth: collisionWidth,
1078					collisionHeight: collisionHeight,
1079					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1080					my: options.my,
1081					at: options.at,
1082					within: within,
1083					elem: elem
1084				} );
1085			}
1086		} );
1087
1088		if ( options.using ) {
1089
1090			// Adds feedback as second argument to using callback, if present
1091			using = function( props ) {
1092				var left = targetOffset.left - position.left,
1093					right = left + targetWidth - elemWidth,
1094					top = targetOffset.top - position.top,
1095					bottom = top + targetHeight - elemHeight,
1096					feedback = {
1097						target: {
1098							element: target,
1099							left: targetOffset.left,
1100							top: targetOffset.top,
1101							width: targetWidth,
1102							height: targetHeight
1103						},
1104						element: {
1105							element: elem,
1106							left: position.left,
1107							top: position.top,
1108							width: elemWidth,
1109							height: elemHeight
1110						},
1111						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1112						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1113					};
1114				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1115					feedback.horizontal = "center";
1116				}
1117				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1118					feedback.vertical = "middle";
1119				}
1120				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1121					feedback.important = "horizontal";
1122				} else {
1123					feedback.important = "vertical";
1124				}
1125				options.using.call( this, props, feedback );
1126			};
1127		}
1128
1129		elem.offset( $.extend( position, { using: using } ) );
1130	} );
1131};
1132
1133$.ui.position = {
1134	fit: {
1135		left: function( position, data ) {
1136			var within = data.within,
1137				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1138				outerWidth = within.width,
1139				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1140				overLeft = withinOffset - collisionPosLeft,
1141				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1142				newOverRight;
1143
1144			// Element is wider than within
1145			if ( data.collisionWidth > outerWidth ) {
1146
1147				// Element is initially over the left side of within
1148				if ( overLeft > 0 && overRight <= 0 ) {
1149					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
1150						withinOffset;
1151					position.left += overLeft - newOverRight;
1152
1153				// Element is initially over right side of within
1154				} else if ( overRight > 0 && overLeft <= 0 ) {
1155					position.left = withinOffset;
1156
1157				// Element is initially over both left and right sides of within
1158				} else {
1159					if ( overLeft > overRight ) {
1160						position.left = withinOffset + outerWidth - data.collisionWidth;
1161					} else {
1162						position.left = withinOffset;
1163					}
1164				}
1165
1166			// Too far left -> align with left edge
1167			} else if ( overLeft > 0 ) {
1168				position.left += overLeft;
1169
1170			// Too far right -> align with right edge
1171			} else if ( overRight > 0 ) {
1172				position.left -= overRight;
1173
1174			// Adjust based on position and margin
1175			} else {
1176				position.left = max( position.left - collisionPosLeft, position.left );
1177			}
1178		},
1179		top: function( position, data ) {
1180			var within = data.within,
1181				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1182				outerHeight = data.within.height,
1183				collisionPosTop = position.top - data.collisionPosition.marginTop,
1184				overTop = withinOffset - collisionPosTop,
1185				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1186				newOverBottom;
1187
1188			// Element is taller than within
1189			if ( data.collisionHeight > outerHeight ) {
1190
1191				// Element is initially over the top of within
1192				if ( overTop > 0 && overBottom <= 0 ) {
1193					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
1194						withinOffset;
1195					position.top += overTop - newOverBottom;
1196
1197				// Element is initially over bottom of within
1198				} else if ( overBottom > 0 && overTop <= 0 ) {
1199					position.top = withinOffset;
1200
1201				// Element is initially over both top and bottom of within
1202				} else {
1203					if ( overTop > overBottom ) {
1204						position.top = withinOffset + outerHeight - data.collisionHeight;
1205					} else {
1206						position.top = withinOffset;
1207					}
1208				}
1209
1210			// Too far up -> align with top
1211			} else if ( overTop > 0 ) {
1212				position.top += overTop;
1213
1214			// Too far down -> align with bottom edge
1215			} else if ( overBottom > 0 ) {
1216				position.top -= overBottom;
1217
1218			// Adjust based on position and margin
1219			} else {
1220				position.top = max( position.top - collisionPosTop, position.top );
1221			}
1222		}
1223	},
1224	flip: {
1225		left: function( position, data ) {
1226			var within = data.within,
1227				withinOffset = within.offset.left + within.scrollLeft,
1228				outerWidth = within.width,
1229				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1230				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1231				overLeft = collisionPosLeft - offsetLeft,
1232				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1233				myOffset = data.my[ 0 ] === "left" ?
1234					-data.elemWidth :
1235					data.my[ 0 ] === "right" ?
1236						data.elemWidth :
1237						0,
1238				atOffset = data.at[ 0 ] === "left" ?
1239					data.targetWidth :
1240					data.at[ 0 ] === "right" ?
1241						-data.targetWidth :
1242						0,
1243				offset = -2 * data.offset[ 0 ],
1244				newOverRight,
1245				newOverLeft;
1246
1247			if ( overLeft < 0 ) {
1248				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
1249					outerWidth - withinOffset;
1250				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1251					position.left += myOffset + atOffset + offset;
1252				}
1253			} else if ( overRight > 0 ) {
1254				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
1255					atOffset + offset - offsetLeft;
1256				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1257					position.left += myOffset + atOffset + offset;
1258				}
1259			}
1260		},
1261		top: function( position, data ) {
1262			var within = data.within,
1263				withinOffset = within.offset.top + within.scrollTop,
1264				outerHeight = within.height,
1265				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1266				collisionPosTop = position.top - data.collisionPosition.marginTop,
1267				overTop = collisionPosTop - offsetTop,
1268				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1269				top = data.my[ 1 ] === "top",
1270				myOffset = top ?
1271					-data.elemHeight :
1272					data.my[ 1 ] === "bottom" ?
1273						data.elemHeight :
1274						0,
1275				atOffset = data.at[ 1 ] === "top" ?
1276					data.targetHeight :
1277					data.at[ 1 ] === "bottom" ?
1278						-data.targetHeight :
1279						0,
1280				offset = -2 * data.offset[ 1 ],
1281				newOverTop,
1282				newOverBottom;
1283			if ( overTop < 0 ) {
1284				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
1285					outerHeight - withinOffset;
1286				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1287					position.top += myOffset + atOffset + offset;
1288				}
1289			} else if ( overBottom > 0 ) {
1290				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
1291					offset - offsetTop;
1292				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1293					position.top += myOffset + atOffset + offset;
1294				}
1295			}
1296		}
1297	},
1298	flipfit: {
1299		left: function() {
1300			$.ui.position.flip.left.apply( this, arguments );
1301			$.ui.position.fit.left.apply( this, arguments );
1302		},
1303		top: function() {
1304			$.ui.position.flip.top.apply( this, arguments );
1305			$.ui.position.fit.top.apply( this, arguments );
1306		}
1307	}
1308};
1309
1310} )();
1311
1312var position = $.ui.position;
1313
1314
1315/*!
1316 * jQuery UI :data 1.12.1
1317 * http://jqueryui.com

1318 *
1319 * Copyright jQuery Foundation and other contributors
1320 * Released under the MIT license.
1321 * http://jquery.org/license
1322 */
1323
1324//>>label: :data Selector
1325//>>group: Core
1326//>>description: Selects elements which have data stored under the specified key.
1327//>>docs: http://api.jqueryui.com/data-selector/
1328
1329
1330var data = $.extend( $.expr[ ":" ], {
1331	data: $.expr.createPseudo ?
1332		$.expr.createPseudo( function( dataName ) {
1333			return function( elem ) {
1334				return !!$.data( elem, dataName );
1335			};
1336		} ) :
1337
1338		// Support: jQuery <1.8
1339		function( elem, i, match ) {
1340			return !!$.data( elem, match[ 3 ] );
1341		}
1342} );
1343
1344/*!
1345 * jQuery UI Disable Selection 1.12.1
1346 * http://jqueryui.com
1347 *
1348 * Copyright jQuery Foundation and other contributors
1349 * Released under the MIT license.
1350 * http://jquery.org/license
1351 */
1352
1353//>>label: disableSelection
1354//>>group: Core
1355//>>description: Disable selection of text content within the set of matched elements.
1356//>>docs: http://api.jqueryui.com/disableSelection/
1357
1358// This file is deprecated
1359
1360
1361var disableSelection = $.fn.extend( {
1362	disableSelection: ( function() {
1363		var eventType = "onselectstart" in document.createElement( "div" ) ?
1364			"selectstart" :
1365			"mousedown";
1366
1367		return function() {
1368			return this.on( eventType + ".ui-disableSelection", function( event ) {
1369				event.preventDefault();
1370			} );
1371		};
1372	} )(),
1373
1374	enableSelection: function() {
1375		return this.off( ".ui-disableSelection" );
1376	}
1377} );
1378
1379
1380/*!
1381 * jQuery UI Focusable 1.12.1
1382 * http://jqueryui.com
1383 *
1384 * Copyright jQuery Foundation and other contributors
1385 * Released under the MIT license.
1386 * http://jquery.org/license
1387 */
1388
1389//>>label: :focusable Selector
1390//>>group: Core
1391//>>description: Selects elements which can be focused.
1392//>>docs: http://api.jqueryui.com/focusable-selector/
1393
1394
1395
1396// Selectors
1397$.ui.focusable = function( element, hasTabindex ) {
1398	var map, mapName, img, focusableIfVisible, fieldset,
1399		nodeName = element.nodeName.toLowerCase();
1400
1401	if ( "area" === nodeName ) {
1402		map = element.parentNode;
1403		mapName = map.name;
1404		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
1405			return false;
1406		}
1407		img = $( "img[usemap='#" + mapName + "']" );
1408		return img.length > 0 && img.is( ":visible" );
1409	}
1410
1411	if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
1412		focusableIfVisible = !element.disabled;
1413
1414		if ( focusableIfVisible ) {
1415
1416			// Form controls within a disabled fieldset are disabled.
1417			// However, controls within the fieldset's legend do not get disabled.
1418			// Since controls generally aren't placed inside legends, we skip
1419			// this portion of the check.
1420			fieldset = $( element ).closest( "fieldset" )[ 0 ];
1421			if ( fieldset ) {
1422				focusableIfVisible = !fieldset.disabled;
1423			}
1424		}
1425	} else if ( "a" === nodeName ) {
1426		focusableIfVisible = element.href || hasTabindex;
1427	} else {
1428		focusableIfVisible = hasTabindex;
1429	}
1430
1431	return focusableIfVisible && $( element ).is( ":visible" ) && visible( $( element ) );
1432};
1433
1434// Support: IE 8 only
1435// IE 8 doesn't resolve inherit to visible/hidden for computed values
1436function visible( element ) {
1437	var visibility = element.css( "visibility" );
1438	while ( visibility === "inherit" ) {
1439		element = element.parent();
1440		visibility = element.css( "visibility" );
1441	}
1442	return visibility !== "hidden";
1443}
1444
1445$.extend( $.expr[ ":" ], {
1446	focusable: function( element ) {
1447		return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
1448	}
1449} );
1450
1451var focusable = $.ui.focusable;
1452
1453
1454
1455
1456// Support: IE8 Only
1457// IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
1458// with a string, so we need to find the proper form.
1459var form = $.fn.form = function() {
1460	return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form );
1461};
1462
1463
1464/*!
1465 * jQuery UI Form Reset Mixin 1.12.1
1466 * http://jqueryui.com
1467 *
1468 * Copyright jQuery Foundation and other contributors
1469 * Released under the MIT license.
1470 * http://jquery.org/license
1471 */
1472
1473//>>label: Form Reset Mixin
1474//>>group: Core
1475//>>description: Refresh input widgets when their form is reset
1476//>>docs: http://api.jqueryui.com/form-reset-mixin/
1477
1478
1479
1480var formResetMixin = $.ui.formResetMixin = {
1481	_formResetHandler: function() {
1482		var form = $( this );
1483
1484		// Wait for the form reset to actually happen before refreshing
1485		setTimeout( function() {
1486			var instances = form.data( "ui-form-reset-instances" );
1487			$.each( instances, function() {
1488				this.refresh();

1489			} );
1490		} );
1491	},
1492
1493	_bindFormResetHandler: function() {
1494		this.form = this.element.form();
1495		if ( !this.form.length ) {
1496			return;
1497		}
1498
1499		var instances = this.form.data( "ui-form-reset-instances" ) || [];
1500		if ( !instances.length ) {
1501
1502			// We don't use _on() here because we use a single event handler per form
1503			this.form.on( "reset.ui-form-reset", this._formResetHandler );
1504		}
1505		instances.push( this );
1506		this.form.data( "ui-form-reset-instances", instances );
1507	},
1508
1509	_unbindFormResetHandler: function() {
1510		if ( !this.form.length ) {
1511			return;
1512		}
1513
1514		var instances = this.form.data( "ui-form-reset-instances" );
1515		instances.splice( $.inArray( this, instances ), 1 );
1516		if ( instances.length ) {
1517			this.form.data( "ui-form-reset-instances", instances );
1518		} else {
1519			this.form
1520				.removeData( "ui-form-reset-instances" )
1521				.off( "reset.ui-form-reset" );
1522		}
1523	}
1524};
1525
1526
1527/*!
1528 * jQuery UI Support for jQuery core 1.7.x 1.12.1
1529 * http://jqueryui.com
1530 *
1531 * Copyright jQuery Foundation and other contributors
1532 * Released under the MIT license.
1533 * http://jquery.org/license
1534 *
1535 */
1536
1537//>>label: jQuery 1.7 Support
1538//>>group: Core
1539//>>description: Support version 1.7.x of jQuery core
1540
1541
1542
1543// Support: jQuery 1.7 only
1544// Not a great way to check versions, but since we only support 1.7+ and only
1545// need to detect <1.8, this is a simple check that should suffice. Checking
1546// for "1.7." would be a bit safer, but the version string is 1.7, not 1.7.0
1547// and we'll never reach 1.70.0 (if we do, we certainly won't be supporting
1548// 1.7 anymore). See #11197 for why we're not using feature detection.
1549if ( $.fn.jquery.substring( 0, 3 ) === "1.7" ) {
1550
1551	// Setters for .innerWidth(), .innerHeight(), .outerWidth(), .outerHeight()
1552	// Unlike jQuery Core 1.8+, these only support numeric values to set the
1553	// dimensions in pixels
1554	$.each( [ "Width", "Height" ], function( i, name ) {
1555		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
1556			type = name.toLowerCase(),
1557			orig = {
1558				innerWidth: $.fn.innerWidth,
1559				innerHeight: $.fn.innerHeight,
1560				outerWidth: $.fn.outerWidth,
1561				outerHeight: $.fn.outerHeight
1562			};
1563
1564		function reduce( elem, size, border, margin ) {
1565			$.each( side, function() {
1566				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
1567				if ( border ) {
1568					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
1569				}
1570				if ( margin ) {
1571					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
1572				}
1573			} );
1574			return size;
1575		}
1576
1577		$.fn[ "inner" + name ] = function( size ) {
1578			if ( size === undefined ) {
1579				return orig[ "inner" + name ].call( this );
1580			}
1581
1582			return this.each( function() {
1583				$( this ).css( type, reduce( this, size ) + "px" );
1584			} );
1585		};
1586
1587		$.fn[ "outer" + name ] = function( size, margin ) {
1588			if ( typeof size !== "number" ) {
1589				return orig[ "outer" + name ].call( this, size );
1590			}
1591
1592			return this.each( function() {
1593				$( this ).css( type, reduce( this, size, true, margin ) + "px" );
1594			} );
1595		};
1596	} );
1597
1598	$.fn.addBack = function( selector ) {
1599		return this.add( selector == null ?
1600			this.prevObject : this.prevObject.filter( selector )
1601		);
1602	};
1603}
1604
1605;
1606/*!
1607 * jQuery UI Keycode 1.12.1
1608 * http://jqueryui.com
1609 *
1610 * Copyright jQuery Foundation and other contributors
1611 * Released under the MIT license.
1612 * http://jquery.org/license
1613 */
1614
1615//>>label: Keycode
1616//>>group: Core
1617//>>description: Provide keycodes as keynames
1618//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
1619
1620
1621var keycode = $.ui.keyCode = {
1622	BACKSPACE: 8,
1623	COMMA: 188,
1624	DELETE: 46,
1625	DOWN: 40,
1626	END: 35,
1627	ENTER: 13,
1628	ESCAPE: 27,
1629	HOME: 36,
1630	LEFT: 37,
1631	PAGE_DOWN: 34,
1632	PAGE_UP: 33,
1633	PERIOD: 190,
1634	RIGHT: 39,
1635	SPACE: 32,
1636	TAB: 9,
1637	UP: 38
1638};
1639
1640
1641
1642
1643// Internal use only
1644var escapeSelector = $.ui.escapeSelector = ( function() {
1645	var selectorEscape = /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;
1646	return function( selector ) {
1647		return selector.replace( selectorEscape, "\\$1" );
1648	};
1649} )();
1650
1651
1652/*!
1653 * jQuery UI Labels 1.12.1
1654 * http://jqueryui.com

1655 *
1656 * Copyright jQuery Foundation and other contributors
1657 * Released under the MIT license.
1658 * http://jquery.org/license
1659 */
1660
1661//>>label: labels
1662//>>group: Core
1663//>>description: Find all the labels associated with a given input
1664//>>docs: http://api.jqueryui.com/labels/
1665
1666
1667
1668var labels = $.fn.labels = function() {
1669	var ancestor, selector, id, labels, ancestors;
1670
1671	// Check control.labels first
1672	if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
1673		return this.pushStack( this[ 0 ].labels );
1674	}
1675
1676	// Support: IE <= 11, FF <= 37, Android <= 2.3 only
1677	// Above browsers do not support control.labels. Everything below is to support them
1678	// as well as document fragments. control.labels does not work on document fragments
1679	labels = this.eq( 0 ).parents( "label" );
1680
1681	// Look for the label based on the id
1682	id = this.attr( "id" );
1683	if ( id ) {
1684
1685		// We don't search against the document in case the element
1686		// is disconnected from the DOM
1687		ancestor = this.eq( 0 ).parents().last();
1688
1689		// Get a full set of top level ancestors
1690		ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
1691
1692		// Create a selector for the label based on the id
1693		selector = "label[for='" + $.ui.escapeSelector( id ) + "']";
1694
1695		labels = labels.add( ancestors.find( selector ).addBack( selector ) );
1696
1697	}
1698
1699	// Return whatever we have found for labels
1700	return this.pushStack( labels );
1701};
1702
1703
1704/*!
1705 * jQuery UI Scroll Parent 1.12.1
1706 * http://jqueryui.com
1707 *
1708 * Copyright jQuery Foundation and other contributors
1709 * Released under the MIT license.
1710 * http://jquery.org/license
1711 */
1712
1713//>>label: scrollParent
1714//>>group: Core
1715//>>description: Get the closest ancestor element that is scrollable.
1716//>>docs: http://api.jqueryui.com/scrollParent/
1717
1718
1719
1720var scrollParent = $.fn.scrollParent = function( includeHidden ) {
1721	var position = this.css( "position" ),
1722		excludeStaticParent = position === "absolute",
1723		overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
1724		scrollParent = this.parents().filter( function() {
1725			var parent = $( this );
1726			if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
1727				return false;
1728			}
1729			return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) +
1730				parent.css( "overflow-x" ) );
1731		} ).eq( 0 );
1732
1733	return position === "fixed" || !scrollParent.length ?
1734		$( this[ 0 ].ownerDocument || document ) :
1735		scrollParent;
1736};
1737
1738
1739/*!
1740 * jQuery UI Tabbable 1.12.1
1741 * http://jqueryui.com
1742 *
1743 * Copyright jQuery Foundation and other contributors
1744 * Released under the MIT license.
1745 * http://jquery.org/license
1746 */
1747
1748//>>label: :tabbable Selector
1749//>>group: Core
1750//>>description: Selects elements which can be tabbed to.
1751//>>docs: http://api.jqueryui.com/tabbable-selector/
1752
1753
1754
1755var tabbable = $.extend( $.expr[ ":" ], {
1756	tabbable: function( element ) {
1757		var tabIndex = $.attr( element, "tabindex" ),
1758			hasTabindex = tabIndex != null;
1759		return ( !hasTabindex || tabIndex >= 0 ) && $.ui.focusable( element, hasTabindex );
1760	}
1761} );
1762
1763
1764/*!
1765 * jQuery UI Unique ID 1.12.1
1766 * http://jqueryui.com
1767 *
1768 * Copyright jQuery Foundation and other contributors
1769 * Released under the MIT license.
1770 * http://jquery.org/license
1771 */
1772
1773//>>label: uniqueId
1774//>>group: Core
1775//>>description: Functions to generate and remove uniqueId's
1776//>>docs: http://api.jqueryui.com/uniqueId/
1777
1778
1779
1780var uniqueId = $.fn.extend( {
1781	uniqueId: ( function() {
1782		var uuid = 0;
1783
1784		return function() {
1785			return this.each( function() {
1786				if ( !this.id ) {
1787					this.id = "ui-id-" + ( ++uuid );
1788				}
1789			} );
1790		};
1791	} )(),
1792
1793	removeUniqueId: function() {
1794		return this.each( function() {
1795			if ( /^ui-id-\d+$/.test( this.id ) ) {
1796				$( this ).removeAttr( "id" );
1797			}
1798		} );
1799	}
1800} );
1801
1802
1803
1804
1805// This file is deprecated
1806var ie = $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
1807
1808/*!
1809 * jQuery UI Mouse 1.12.1
1810 * http://jqueryui.com
1811 *
1812 * Copyright jQuery Foundation and other contributors
1813 * Released under the MIT license.
1814 * http://jquery.org/license
1815 */
1816
1817//>>label: Mouse
1818//>>group: Widgets
1819//>>description: Abstracts mouse-based interactions to assist in creating certain widgets.
1820//>>docs: http://api.jqueryui.com/mouse/
1821
1822
1823
1824var mouseHandled = false;
1825$( document ).on( "mouseup", function() {
1826	mouseHandled = false;
1827} );
1828
1829var widgetsMouse = $.widget( "ui.mouse", {
1830	version: "1.12.1",
1831	options: {
1832		cancel: "input, textarea, button, select, option",
1833		distance: 1,
1834		delay: 0
1835	},

1836	_mouseInit: function() {
1837		var that = this;
1838
1839		this.element
1840			.on( "mousedown." + this.widgetName, function( event ) {
1841				return that._mouseDown( event );
1842			} )
1843			.on( "click." + this.widgetName, function( event ) {
1844				if ( true === $.data( event.target, that.widgetName + ".preventClickEvent" ) ) {
1845					$.removeData( event.target, that.widgetName + ".preventClickEvent" );
1846					event.stopImmediatePropagation();
1847					return false;
1848				}
1849			} );
1850
1851		this.started = false;
1852	},
1853
1854	// TODO: make sure destroying one instance of mouse doesn't mess with
1855	// other instances of mouse
1856	_mouseDestroy: function() {
1857		this.element.off( "." + this.widgetName );
1858		if ( this._mouseMoveDelegate ) {
1859			this.document
1860				.off( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1861				.off( "mouseup." + this.widgetName, this._mouseUpDelegate );
1862		}
1863	},
1864
1865	_mouseDown: function( event ) {
1866
1867		// don't let more than one widget handle mouseStart
1868		if ( mouseHandled ) {
1869			return;
1870		}
1871
1872		this._mouseMoved = false;
1873
1874		// We may have missed mouseup (out of window)
1875		( this._mouseStarted && this._mouseUp( event ) );
1876
1877		this._mouseDownEvent = event;
1878
1879		var that = this,
1880			btnIsLeft = ( event.which === 1 ),
1881
1882			// event.target.nodeName works around a bug in IE 8 with
1883			// disabled inputs (#7620)
1884			elIsCancel = ( typeof this.options.cancel === "string" && event.target.nodeName ?
1885				$( event.target ).closest( this.options.cancel ).length : false );
1886		if ( !btnIsLeft || elIsCancel || !this._mouseCapture( event ) ) {
1887			return true;
1888		}
1889
1890		this.mouseDelayMet = !this.options.delay;
1891		if ( !this.mouseDelayMet ) {
1892			this._mouseDelayTimer = setTimeout( function() {
1893				that.mouseDelayMet = true;
1894			}, this.options.delay );
1895		}
1896
1897		if ( this._mouseDistanceMet( event ) && this._mouseDelayMet( event ) ) {
1898			this._mouseStarted = ( this._mouseStart( event ) !== false );
1899			if ( !this._mouseStarted ) {
1900				event.preventDefault();
1901				return true;
1902			}
1903		}
1904
1905		// Click event may never have fired (Gecko & Opera)
1906		if ( true === $.data( event.target, this.widgetName + ".preventClickEvent" ) ) {
1907			$.removeData( event.target, this.widgetName + ".preventClickEvent" );
1908		}
1909
1910		// These delegates are required to keep context
1911		this._mouseMoveDelegate = function( event ) {
1912			return that._mouseMove( event );
1913		};
1914		this._mouseUpDelegate = function( event ) {
1915			return that._mouseUp( event );
1916		};
1917
1918		this.document
1919			.on( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1920			.on( "mouseup." + this.widgetName, this._mouseUpDelegate );
1921
1922		event.preventDefault();
1923
1924		mouseHandled = true;
1925		return true;
1926	},
1927
1928	_mouseMove: function( event ) {
1929
1930		// Only check for mouseups outside the document if you've moved inside the document
1931		// at least once. This prevents the firing of mouseup in the case of IE<9, which will
1932		// fire a mousemove event if content is placed under the cursor. See #7778

1933		// Support: IE <9
1934		if ( this._mouseMoved ) {
1935
1936			// IE mouseup check - mouseup happened when mouse was out of window
1937			if ( $.ui.ie && ( !document.documentMode || document.documentMode < 9 ) &&
1938					!event.button ) {
1939				return this._mouseUp( event );
1940
1941			// Iframe mouseup check - mouseup occurred in another document
1942			} else if ( !event.which ) {
1943
1944				// Support: Safari <=8 - 9
1945				// Safari sets which to 0 if you press any of the following keys
1946				// during a drag (#14461)
1947				if ( event.originalEvent.altKey || event.originalEvent.ctrlKey ||
1948						event.originalEvent.metaKey || event.originalEvent.shiftKey ) {
1949					this.ignoreMissingWhich = true;
1950				} else if ( !this.ignoreMissingWhich ) {
1951					return this._mouseUp( event );
1952				}
1953			}
1954		}
1955
1956		if ( event.which || event.button ) {
1957			this._mouseMoved = true;
1958		}
1959
1960		if ( this._mouseStarted ) {
1961			this._mouseDrag( event );
1962			return event.preventDefault();
1963		}
1964
1965		if ( this._mouseDistanceMet( event ) && this._mouseDelayMet( event ) ) {
1966			this._mouseStarted =
1967				( this._mouseStart( this._mouseDownEvent, event ) !== false );
1968			( this._mouseStarted ? this._mouseDrag( event ) : this._mouseUp( event ) );
1969		}
1970
1971		return !this._mouseStarted;
1972	},
1973
1974	_mouseUp: function( event ) {
1975		this.document
1976			.off( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1977			.off( "mouseup." + this.widgetName, this._mouseUpDelegate );
1978
1979		if ( this._mouseStarted ) {
1980			this._mouseStarted = false;
1981
1982			if ( event.target === this._mouseDownEvent.target ) {
1983				$.data( event.target, this.widgetName + ".preventClickEvent", true );
1984			}
1985
1986			this._mouseStop( event );
1987		}
1988
1989		if ( this._mouseDelayTimer ) {
1990			clearTimeout( this._mouseDelayTimer );
1991			delete this._mouseDelayTimer;
1992		}
1993
1994		this.ignoreMissingWhich = false;
1995		mouseHandled = false;
1996		event.preventDefault();
1997	},
1998
1999	_mouseDistanceMet: function( event ) {
2000		return ( Math.max(
2001				Math.abs( this._mouseDownEvent.pageX - event.pageX ),
2002				Math.abs( this._mouseDownEvent.pageY - event.pageY )
2003			) >= this.options.distance
2004		);
2005	},
2006
2007	_mouseDelayMet: function( /* event */ ) {
2008		return this.mouseDelayMet;
2009	},
2010
2011	// These are placeholder methods, to be overriden by extending plugin
2012	_mouseStart: function( /* event */ ) {},
2013	_mouseDrag: function( /* event */ ) {},
2014	_mouseStop: function( /* event */ ) {},
2015	_mouseCapture: function( /* event */ ) { return true; }
2016} );
2017
2018
2019
2020
2021// $.ui.plugin is deprecated. Use $.widget() extensions instead.
2022var plugin = $.ui.plugin = {
2023	add: function( module, option, set ) {
2024		var i,
2025			proto = $.ui[ module ].prototype;
2026		for ( i in set ) {
2027			proto.plugins[ i ] = proto.plugins[ i ] || [];
2028			proto.plugins[ i ].push( [ option, set[ i ] ] );
2029		}
2030	},
2031	call: function( instance, name, args, allowDisconnected ) {
2032		var i,
2033			set = instance.plugins[ name ];
2034
2035		if ( !set ) {
2036			return;
2037		}
2038
2039		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode ||
2040				instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
2041			return;
2042		}
2043
2044		for ( i = 0; i < set.length; i++ ) {
2045			if ( instance.options[ set[ i ][ 0 ] ] ) {
2046				set[ i ][ 1 ].apply( instance.element, args );
2047			}
2048		}
2049	}
2050};
2051
2052
2053
2054var safeActiveElement = $.ui.safeActiveElement = function( document ) {
2055	var activeElement;
2056
2057	// Support: IE 9 only
2058	// IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
2059	try {
2060		activeElement = document.activeElement;
2061	} catch ( error ) {
2062		activeElement = document.body;
2063	}
2064
2065	// Support: IE 9 - 11 only
2066	// IE may return null instead of an element
2067	// Interestingly, this only seems to occur when NOT in an iframe
2068	if ( !activeElement ) {
2069		activeElement = document.body;
2070	}
2071
2072	// Support: IE 11 only
2073	// IE11 returns a seemingly empty object in some cases when accessing
2074	// document.activeElement from an <iframe>
2075	if ( !activeElement.nodeName ) {
2076		activeElement = document.body;
2077	}
2078
2079	return activeElement;
2080};
2081
2082
2083
2084var safeBlur = $.ui.safeBlur = function( element ) {
2085
2086	// Support: IE9 - 10 only
2087	// If the <body data-rsssl=1> is blurred, IE will switch windows, see #9420
2088	if ( element && element.nodeName.toLowerCase() !== "body" ) {
2089		$( element ).trigger( "blur" );
2090	}
2091};
2092
2093
2094/*!
2095 * jQuery UI Draggable 1.12.1
2096 * http://jqueryui.com

2097 *
2098 * Copyright jQuery Foundation and other contributors
2099 * Released under the MIT license.
2100 * http://jquery.org/license
2101 */
2102
2103//>>label: Draggable
2104//>>group: Interactions
2105//>>description: Enables dragging functionality for any element.
2106//>>docs: http://api.jqueryui.com/draggable/
2107//>>demos: http://jqueryui.com/draggable/
2108//>>css.structure: ../../themes/base/draggable.css
2109
2110
2111
2112$.widget( "ui.draggable", $.ui.mouse, {
2113	version: "1.12.1",
2114	widgetEventPrefix: "drag",
2115	options: {
2116		addClasses: true,
2117		appendTo: "parent",
2118		axis: false,
2119		connectToSortable: false,
2120		containment: false,
2121		cursor: "auto",
2122		cursorAt: false,
2123		grid: false,
2124		handle: false,
2125		helper: "original",
2126		iframeFix: false,
2127		opacity: false,
2128		refreshPositions: false,
2129		revert: false,
2130		revertDuration: 500,
2131		scope: "default",
2132		scroll: true,
2133		scrollSensitivity: 20,
2134		scrollSpeed: 20,
2135		snap: false,
2136		snapMode: "both",
2137		snapTolerance: 20,
2138		stack: false,
2139		zIndex: false,
2140
2141		// Callbacks
2142		drag: null,
2143		start: null,
2144		stop: null
2145	},
2146	_create: function() {
2147
2148		if ( this.options.helper === "original" ) {
2149			this._setPositionRelative();
2150		}
2151		if ( this.options.addClasses ) {
2152			this._addClass( "ui-draggable" );
2153		}
2154		this._setHandleClassName();
2155
2156		this._mouseInit();
2157	},
2158
2159	_setOption: function( key, value ) {
2160		this._super( key, value );
2161		if ( key === "handle" ) {
2162			this._removeHandleClassName();
2163			this._setHandleClassName();
2164		}
2165	},
2166
2167	_destroy: function() {
2168		if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
2169			this.destroyOnClear = true;
2170			return;
2171		}
2172		this._removeHandleClassName();
2173		this._mouseDestroy();
2174	},
2175
2176	_mouseCapture: function( event ) {
2177		var o = this.options;
2178
2179		// Among others, prevent a drag on a resizable-handle
2180		if ( this.helper || o.disabled ||
2181				$( event.target ).closest( ".ui-resizable-handle" ).length > 0 ) {
2182			return false;
2183		}
2184
2185		//Quit if we're not on a valid handle
2186		this.handle = this._getHandle( event );
2187		if ( !this.handle ) {
2188			return false;
2189		}
2190
2191		this._blurActiveElement( event );
2192
2193		this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
2194
2195		return true;
2196
2197	},
2198
2199	_blockFrames: function( selector ) {
2200		this.iframeBlocks = this.document.find( selector ).map( function() {
2201			var iframe = $( this );
2202
2203			return $( "<div>" )
2204				.css( "position", "absolute" )
2205				.appendTo( iframe.parent() )
2206				.outerWidth( iframe.outerWidth() )
2207				.outerHeight( iframe.outerHeight() )
2208				.offset( iframe.offset() )[ 0 ];
2209		} );
2210	},
2211
2212	_unblockFrames: function() {
2213		if ( this.iframeBlocks ) {
2214			this.iframeBlocks.remove();
2215			delete this.iframeBlocks;
2216		}
2217	},
2218
2219	_blurActiveElement: function( event ) {
2220		var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),
2221			target = $( event.target );
2222
2223		// Don't blur if the event occurred on an element that is within
2224		// the currently focused element
2225		// See #10527, #12472
2226		if ( target.closest( activeElement ).length ) {
2227			return;
2228		}
2229
2230		// Blur any element that currently has focus, see #4261
2231		$.ui.safeBlur( activeElement );
2232	},
2233
2234	_mouseStart: function( event ) {
2235
2236		var o = this.options;
2237
2238		//Create and append the visible helper
2239		this.helper = this._createHelper( event );
2240
2241		this._addClass( this.helper, "ui-draggable-dragging" );
2242
2243		//Cache the helper size
2244		this._cacheHelperProportions();
2245
2246		//If ddmanager is used for droppables, set the global draggable
2247		if ( $.ui.ddmanager ) {
2248			$.ui.ddmanager.current = this;
2249		}
2250
2251		/*
2252		 * - Position generation -
2253		 * This block generates everything position related - it's the core of draggables.
2254		 */
2255
2256		//Cache the margins of the original element
2257		this._cacheMargins();
2258
2259		//Store the helper's css position
2260		this.cssPosition = this.helper.css( "position" );
2261		this.scrollParent = this.helper.scrollParent( true );
2262		this.offsetParent = this.helper.offsetParent();
2263		this.hasFixedAncestor = this.helper.parents().filter( function() {
2264				return $( this ).css( "position" ) === "fixed";
2265			} ).length > 0;

2266
2267		//The element's absolute position on the page minus margins
2268		this.positionAbs = this.element.offset();
2269		this._refreshOffsets( event );
2270
2271		//Generate the original position
2272		this.originalPosition = this.position = this._generatePosition( event, false );
2273		this.originalPageX = event.pageX;
2274		this.originalPageY = event.pageY;
2275
2276		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
2277		( o.cursorAt && this._adjustOffsetFromHelper( o.cursorAt ) );
2278
2279		//Set a containment if given in the options
2280		this._setContainment();
2281
2282		//Trigger event + callbacks
2283		if ( this._trigger( "start", event ) === false ) {
2284			this._clear();
2285			return false;
2286		}
2287
2288		//Recache the helper size
2289		this._cacheHelperProportions();
2290
2291		//Prepare the droppable offsets
2292		if ( $.ui.ddmanager && !o.dropBehaviour ) {
2293			$.ui.ddmanager.prepareOffsets( this, event );
2294		}
2295
2296		// Execute the drag once - this causes the helper not to be visible before getting its
2297		// correct position
2298		this._mouseDrag( event, true );
2299
2300		// If the ddmanager is used for droppables, inform the manager that dragging has started
2301		// (see #5003)
2302		if ( $.ui.ddmanager ) {
2303			$.ui.ddmanager.dragStart( this, event );
2304		}
2305
2306		return true;
2307	},
2308
2309	_refreshOffsets: function( event ) {
2310		this.offset = {
2311			top: this.positionAbs.top - this.margins.top,
2312			left: this.positionAbs.left - this.margins.left,
2313			scroll: false,
2314			parent: this._getParentOffset(),
2315			relative: this._getRelativeOffset()
2316		};
2317
2318		this.offset.click = {
2319			left: event.pageX - this.offset.left,
2320			top: event.pageY - this.offset.top
2321		};
2322	},
2323
2324	_mouseDrag: function( event, noPropagation ) {
2325
2326		// reset any necessary cached properties (see #5009)
2327		if ( this.hasFixedAncestor ) {
2328			this.offset.parent = this._getParentOffset();
2329		}
2330
2331		//Compute the helpers position
2332		this.position = this._generatePosition( event, true );
2333		this.positionAbs = this._convertPositionTo( "absolute" );
2334
2335		//Call plugins and callbacks and use the resulting position if something is returned
2336		if ( !noPropagation ) {
2337			var ui = this._uiHash();
2338			if ( this._trigger( "drag", event, ui ) === false ) {
2339				this._mouseUp( new $.Event( "mouseup", event ) );
2340				return false;
2341			}
2342			this.position = ui.position;
2343		}
2344
2345		this.helper[ 0 ].style.left = this.position.left + "px";
2346		this.helper[ 0 ].style.top = this.position.top + "px";
2347
2348		if ( $.ui.ddmanager ) {
2349			$.ui.ddmanager.drag( this, event );
2350		}
2351
2352		return false;
2353	},
2354
2355	_mouseStop: function( event ) {
2356
2357		//If we are using droppables, inform the manager about the drop
2358		var that = this,
2359			dropped = false;
2360		if ( $.ui.ddmanager && !this.options.dropBehaviour ) {
2361			dropped = $.ui.ddmanager.drop( this, event );
2362		}
2363
2364		//if a drop comes from outside (a sortable)
2365		if ( this.dropped ) {
2366			dropped = this.dropped;
2367			this.dropped = false;
2368		}
2369
2370		if ( ( this.options.revert === "invalid" && !dropped ) ||
2371				( this.options.revert === "valid" && dropped ) ||
2372				this.options.revert === true || ( $.isFunction( this.options.revert ) &&
2373				this.options.revert.call( this.element, dropped ) )
2374		) {
2375			$( this.helper ).animate(
2376				this.originalPosition,
2377				parseInt( this.options.revertDuration, 10 ),
2378				function() {
2379					if ( that._trigger( "stop", event ) !== false ) {
2380						that._clear();
2381					}
2382				}
2383			);
2384		} else {
2385			if ( this._trigger( "stop", event ) !== false ) {
2386				this._clear();
2387			}
2388		}
2389
2390		return false;
2391	},
2392
2393	_mouseUp: function( event ) {
2394		this._unblockFrames();
2395
2396		// If the ddmanager is used for droppables, inform the manager that dragging has stopped
2397		// (see #5003)
2398		if ( $.ui.ddmanager ) {
2399			$.ui.ddmanager.dragStop( this, event );
2400		}
2401
2402		// Only need to focus if the event occurred on the draggable itself, see #10527
2403		if ( this.handleElement.is( event.target ) ) {
2404
2405			// The interaction is over; whether or not the click resulted in a drag,
2406			// focus the element
2407			this.element.trigger( "focus" );
2408		}
2409
2410		return $.ui.mouse.prototype._mouseUp.call( this, event );
2411	},
2412
2413	cancel: function() {
2414
2415		if ( this.helper.is( ".ui-draggable-dragging" ) ) {
2416			this._mouseUp( new $.Event( "mouseup", { target: this.element[ 0 ] } ) );
2417		} else {
2418			this._clear();
2419		}
2420
2421		return this;
2422
2423	},
2424
2425	_getHandle: function( event ) {
2426		return this.options.handle ?
2427			!!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
2428			true;
2429	},
2430
2431	_setHandleClassName: function() {
2432		this.handleElement = this.options.handle ?
2433			this.element.find( this.options.handle ) : this.element;
2434		this._addClass( this.handleElement, "ui-draggable-handle" );
2435	},
2436
2437	_removeHandleClassName: function() {
2438		this._removeClass( this.handleElement, "ui-draggable-handle" );
2439	},
2440
2441	_createHelper: function( event ) {
2442
2443		var o = this.options,
2444			helperIsFunction = $.isFunction( o.helper ),
2445			helper = helperIsFunction ?
2446				$( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
2447				( o.helper === "clone" ?
2448					this.element.clone().removeAttr( "id" ) :
2449					this.element );
2450
2451		if ( !helper.parents( "body" ).length ) {
2452			helper.appendTo( ( o.appendTo === "parent" ?
2453				this.element[ 0 ].parentNode :
2454				o.appendTo ) );
2455		}
2456
2457		// Http://bugs.jqueryui.com/ticket/9446
2458		// a helper function can return the original element

2459		// which wouldn't have been set to relative in _create
2460		if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
2461			this._setPositionRelative();
2462		}
2463
2464		if ( helper[ 0 ] !== this.element[ 0 ] &&
2465				!( /(fixed|absolute)/ ).test( helper.css( "position" ) ) ) {
2466			helper.css( "position", "absolute" );
2467		}
2468
2469		return helper;
2470
2471	},
2472
2473	_setPositionRelative: function() {
2474		if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
2475			this.element[ 0 ].style.position = "relative";
2476		}
2477	},
2478
2479	_adjustOffsetFromHelper: function( obj ) {
2480		if ( typeof obj === "string" ) {
2481			obj = obj.split( " " );
2482		}
2483		if ( $.isArray( obj ) ) {
2484			obj = { left: +obj[ 0 ], top: +obj[ 1 ] || 0 };
2485		}
2486		if ( "left" in obj ) {
2487			this.offset.click.left = obj.left + this.margins.left;
2488		}
2489		if ( "right" in obj ) {
2490			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
2491		}
2492		if ( "top" in obj ) {
2493			this.offset.click.top = obj.top + this.margins.top;
2494		}
2495		if ( "bottom" in obj ) {
2496			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
2497		}
2498	},
2499
2500	_isRootNode: function( element ) {
2501		return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
2502	},
2503
2504	_getParentOffset: function() {
2505
2506		//Get the offsetParent and cache its position
2507		var po = this.offsetParent.offset(),
2508			document = this.document[ 0 ];
2509
2510		// This is a special case where we need to modify a offset calculated on start, since the
2511		// following happened:
2512		// 1. The position of the helper is absolute, so it's position is calculated based on the
2513		// next positioned parent
2514		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
2515		// the document, which means that the scroll is included in the initial calculation of the
2516		// offset of the parent, and never recalculated upon drag
2517		if ( this.cssPosition === "absolute" && this.scrollParent[ 0 ] !== document &&
2518				$.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) {
2519			po.left += this.scrollParent.scrollLeft();
2520			po.top += this.scrollParent.scrollTop();
2521		}
2522
2523		if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
2524			po = { top: 0, left: 0 };
2525		}
2526
2527		return {
2528			top: po.top + ( parseInt( this.offsetParent.css( "borderTopWidth" ), 10 ) || 0 ),
2529			left: po.left + ( parseInt( this.offsetParent.css( "borderLeftWidth" ), 10 ) || 0 )
2530		};
2531
2532	},
2533
2534	_getRelativeOffset: function() {
2535		if ( this.cssPosition !== "relative" ) {
2536			return { top: 0, left: 0 };
2537		}
2538
2539		var p = this.element.position(),
2540			scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
2541
2542		return {
2543			top: p.top - ( parseInt( this.helper.css( "top" ), 10 ) || 0 ) +
2544				( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
2545			left: p.left - ( parseInt( this.helper.css( "left" ), 10 ) || 0 ) +
2546				( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
2547		};
2548
2549	},
2550
2551	_cacheMargins: function() {
2552		this.margins = {
2553			left: ( parseInt( this.element.css( "marginLeft" ), 10 ) || 0 ),
2554			top: ( parseInt( this.element.css( "marginTop" ), 10 ) || 0 ),
2555			right: ( parseInt( this.element.css( "marginRight" ), 10 ) || 0 ),
2556			bottom: ( parseInt( this.element.css( "marginBottom" ), 10 ) || 0 )
2557		};
2558	},
2559
2560	_cacheHelperProportions: function() {
2561		this.helperProportions = {
2562			width: this.helper.outerWidth(),
2563			height: this.helper.outerHeight()
2564		};
2565	},
2566
2567	_setContainment: function() {
2568
2569		var isUserScrollable, c, ce,
2570			o = this.options,
2571			document = this.document[ 0 ];
2572
2573		this.relativeContainer = null;
2574
2575		if ( !o.containment ) {
2576			this.containment = null;
2577			return;
2578		}
2579
2580		if ( o.containment === "window" ) {
2581			this.containment = [
2582				$( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
2583				$( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
2584				$( window ).scrollLeft() + $( window ).width() -
2585					this.helperProportions.width - this.margins.left,
2586				$( window ).scrollTop() +
2587					( $( window ).height() || document.body.parentNode.scrollHeight ) -
2588					this.helperProportions.height - this.margins.top
2589			];
2590			return;
2591		}
2592
2593		if ( o.containment === "document" ) {
2594			this.containment = [
2595				0,
2596				0,
2597				$( document ).width() - this.helperProportions.width - this.margins.left,
2598				( $( document ).height() || document.body.parentNode.scrollHeight ) -
2599					this.helperProportions.height - this.margins.top
2600			];
2601			return;
2602		}
2603
2604		if ( o.containment.constructor === Array ) {
2605			this.containment = o.containment;
2606			return;
2607		}
2608
2609		if ( o.containment === "parent" ) {
2610			o.containment = this.helper[ 0 ].parentNode;
2611		}
2612
2613		c = $( o.containment );
2614		ce = c[ 0 ];
2615
2616		if ( !ce ) {
2617			return;
2618		}
2619
2620		isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
2621
2622		this.containment = [
2623			( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) +
2624				( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
2625			( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) +
2626				( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
2627			( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
2628				( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
2629				( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
2630				this.helperProportions.width -
2631				this.margins.left -
2632				this.margins.right,
2633			( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
2634				( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
2635				( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
2636				this.helperProportions.height -
2637				this.margins.top -
2638				this.margins.bottom
2639		];
2640		this.relativeContainer = c;
2641	},
2642
2643	_convertPositionTo: function( d, pos ) {
2644
2645		if ( !pos ) {
2646			pos = this.position;
2647		}
2648
2649		var mod = d === "absolute" ? 1 : -1,
2650			scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
2651
2652		return {
2653			top: (
2654
2655				// The absolute mouse position
2656				pos.top	+
2657
2658				// Only for relative positioned nodes: Relative offset from element to offset parent
2659				this.offset.relative.top * mod +
2660
2661				// The offsetParent's offset without borders (offset + border)
2662				this.offset.parent.top * mod -
2663				( ( this.cssPosition === "fixed" ?
2664					-this.offset.scroll.top :
2665					( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod )
2666			),
2667			left: (
2668
2669				// The absolute mouse position
2670				pos.left +
2671
2672				// Only for relative positioned nodes: Relative offset from element to offset parent
2673				this.offset.relative.left * mod +
2674
2675				// The offsetParent's offset without borders (offset + border)
2676				this.offset.parent.left * mod	-
2677				( ( this.cssPosition === "fixed" ?
2678					-this.offset.scroll.left :
2679					( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod )
2680			)
2681		};
2682
2683	},
2684
2685	_generatePosition: function( event, constrainPosition ) {
2686
2687		var containment, co, top, left,
2688			o = this.options,
2689			scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
2690			pageX = event.pageX,
2691			pageY = event.pageY;
2692
2693		// Cache the scroll
2694		if ( !scrollIsRootNode || !this.offset.scroll ) {
2695			this.offset.scroll = {
2696				top: this.scrollParent.scrollTop(),
2697				left: this.scrollParent.scrollLeft()
2698			};
2699		}
2700
2701		/*
2702		 * - Position constraining -
2703		 * Constrain the position to a mix of grid, containment.
2704		 */
2705
2706		// If we are not dragging yet, we won't check for options
2707		if ( constrainPosition ) {
2708			if ( this.containment ) {
2709				if ( this.relativeContainer ) {
2710					co = this.relativeContainer.offset();
2711					containment = [
2712						this.containment[ 0 ] + co.left,
2713						this.containment[ 1 ] + co.top,
2714						this.containment[ 2 ] + co.left,
2715						this.containment[ 3 ] + co.top
2716					];
2717				} else {
2718					containment = this.containment;
2719				}
2720
2721				if ( event.pageX - this.offset.click.left < containment[ 0 ] ) {
2722					pageX = containment[ 0 ] + this.offset.click.left;
2723				}
2724				if ( event.pageY - this.offset.click.top < containment[ 1 ] ) {
2725					pageY = containment[ 1 ] + this.offset.click.top;
2726				}
2727				if ( event.pageX - this.offset.click.left > containment[ 2 ] ) {
2728					pageX = containment[ 2 ] + this.offset.click.left;
2729				}
2730				if ( event.pageY - this.offset.click.top > containment[ 3 ] ) {
2731					pageY = containment[ 3 ] + this.offset.click.top;
2732				}
2733			}
2734
2735			if ( o.grid ) {
2736
2737				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid
2738				// argument errors in IE (see ticket #6950)
2739				top = o.grid[ 1 ] ? this.originalPageY + Math.round( ( pageY -
2740					this.originalPageY ) / o.grid[ 1 ] ) * o.grid[ 1 ] : this.originalPageY;
2741				pageY = containment ? ( ( top - this.offset.click.top >= containment[ 1 ] ||
2742					top - this.offset.click.top > containment[ 3 ] ) ?
2743						top :
2744						( ( top - this.offset.click.top >= containment[ 1 ] ) ?
2745							top - o.grid[ 1 ] : top + o.grid[ 1 ] ) ) : top;
2746
2747				left = o.grid[ 0 ] ? this.originalPageX +
2748					Math.round( ( pageX - this.originalPageX ) / o.grid[ 0 ] ) * o.grid[ 0 ] :
2749					this.originalPageX;
2750				pageX = containment ? ( ( left - this.offset.click.left >= containment[ 0 ] ||
2751					left - this.offset.click.left > containment[ 2 ] ) ?
2752						left :
2753						( ( left - this.offset.click.left >= containment[ 0 ] ) ?
2754							left - o.grid[ 0 ] : left + o.grid[ 0 ] ) ) : left;
2755			}
2756
2757			if ( o.axis === "y" ) {
2758				pageX = this.originalPageX;
2759			}
2760
2761			if ( o.axis === "x" ) {
2762				pageY = this.originalPageY;
2763			}
2764		}
2765
2766		return {
2767			top: (
2768
2769				// The absolute mouse position
2770				pageY -
2771
2772				// Click offset (relative to the element)
2773				this.offset.click.top -
2774
2775				// Only for relative positioned nodes: Relative offset from element to offset parent
2776				this.offset.relative.top -
2777
2778				// The offsetParent's offset without borders (offset + border)
2779				this.offset.parent.top +
2780				( this.cssPosition === "fixed" ?
2781					-this.offset.scroll.top :
2782					( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
2783			),
2784			left: (
2785
2786				// The absolute mouse position
2787				pageX -
2788
2789				// Click offset (relative to the element)
2790				this.offset.click.left -
2791
2792				// Only for relative positioned nodes: Relative offset from element to offset parent
2793				this.offset.relative.left -
2794
2795				// The offsetParent's offset without borders (offset + border)
2796				this.offset.parent.left +
2797				( this.cssPosition === "fixed" ?
2798					-this.offset.scroll.left :
2799					( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
2800			)
2801		};
2802
2803	},
2804
2805	_clear: function() {
2806		this._removeClass( this.helper, "ui-draggable-dragging" );
2807		if ( this.helper[ 0 ] !== this.element[ 0 ] && !this.cancelHelperRemoval ) {
2808			this.helper.remove();
2809		}
2810		this.helper = null;
2811		this.cancelHelperRemoval = false;
2812		if ( this.destroyOnClear ) {
2813			this.destroy();
2814		}
2815	},
2816
2817	// From now on bulk stuff - mainly helpers
2818
2819	_trigger: function( type, event, ui ) {
2820		ui = ui || this._uiHash();
2821		$.ui.plugin.call( this, type, [ event, ui, this ], true );
2822
2823		// Absolute position and offset (see #6884 ) have to be recalculated after plugins
2824		if ( /^(drag|start|stop)/.test( type ) ) {
2825			this.positionAbs = this._convertPositionTo( "absolute" );
2826			ui.offset = this.positionAbs;
2827		}
2828		return $.Widget.prototype._trigger.call( this, type, event, ui );
2829	},
2830
2831	plugins: {},
2832
2833	_uiHash: function() {
2834		return {
2835			helper: this.helper,
2836			position: this.position,
2837			originalPosition: this.originalPosition,
2838			offset: this.positionAbs
2839		};
2840	}
2841
2842} );
2843
2844$.ui.plugin.add( "draggable", "connectToSortable", {
2845	start: function( event, ui, draggable ) {
2846		var uiSortable = $.extend( {}, ui, {
2847			item: draggable.element
2848		} );
2849
2850		draggable.sortables = [];
2851		$( draggable.options.connectToSortable ).each( function() {
2852			var sortable = $( this ).sortable( "instance" );
2853
2854			if ( sortable && !sortable.options.disabled ) {
2855				draggable.sortables.push( sortable );
2856
2857				// RefreshPositions is called at drag start to refresh the containerCache
2858				// which is used in drag. This ensures it's initialized and synchronized
2859				// with any changes that might have happened on the page since initialization.
2860				sortable.refreshPositions();
2861				sortable._trigger( "activate", event, uiSortable );
2862			}
2863		} );
2864	},
2865	stop: function( event, ui, draggable ) {
2866		var uiSortable = $.extend( {}, ui, {
2867			item: draggable.element
2868		} );
2869
2870		draggable.cancelHelperRemoval = false;
2871
2872		$.each( draggable.sortables, function() {
2873			var sortable = this;
2874
2875			if ( sortable.isOver ) {
2876				sortable.isOver = 0;
2877
2878				// Allow this sortable to handle removing the helper
2879				draggable.cancelHelperRemoval = true;
2880				sortable.cancelHelperRemoval = false;
2881
2882				// Use _storedCSS To restore properties in the sortable,
2883				// as this also handles revert (#9675) since the draggable
2884				// may have modified them in unexpected ways (#8809)
2885				sortable._storedCSS = {
2886					position: sortable.placeholder.css( "position" ),
2887					top: sortable.placeholder.css( "top" ),
2888					left: sortable.placeholder.css( "left" )
2889				};
2890
2891				sortable._mouseStop( event );
2892
2893				// Once drag has ended, the sortable should return to using
2894				// its original helper, not the shared helper from draggable
2895				sortable.options.helper = sortable.options._helper;
2896			} else {
2897
2898				// Prevent this Sortable from removing the helper.
2899				// However, don't set the draggable to remove the helper
2900				// either as another connected Sortable may yet handle the removal.
2901				sortable.cancelHelperRemoval = true;
2902
2903				sortable._trigger( "deactivate", event, uiSortable );
2904			}
2905		} );
2906	},
2907	drag: function( event, ui, draggable ) {
2908		$.each( draggable.sortables, function() {
2909			var innermostIntersecting = false,
2910				sortable = this;
2911
2912			// Copy over variables that sortable's _intersectsWith uses
2913			sortable.positionAbs = draggable.positionAbs;
2914			sortable.helperProportions = draggable.helperProportions;
2915			sortable.offset.click = draggable.offset.click;
2916
2917			if ( sortable._intersectsWith( sortable.containerCache ) ) {
2918				innermostIntersecting = true;
2919
2920				$.each( draggable.sortables, function() {
2921
2922					// Copy over variables that sortable's _intersectsWith uses
2923					this.positionAbs = draggable.positionAbs;
2924					this.helperProportions = draggable.helperProportions;
2925					this.offset.click = draggable.offset.click;
2926
2927					if ( this !== sortable &&
2928							this._intersectsWith( this.containerCache ) &&
2929							$.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
2930						innermostIntersecting = false;
2931					}
2932
2933					return innermostIntersecting;
2934				} );
2935			}
2936
2937			if ( innermostIntersecting ) {
2938
2939				// If it intersects, we use a little isOver variable and set it once,
2940				// so that the move-in stuff gets fired only once.
2941				if ( !sortable.isOver ) {
2942					sortable.isOver = 1;
2943
2944					// Store draggable's parent in case we need to reappend to it later.
2945					draggable._parent = ui.helper.parent();
2946
2947					sortable.currentItem = ui.helper
2948						.appendTo( sortable.element )
2949						.data( "ui-sortable-item", true );
2950
2951					// Store helper option to later restore it