https://login.relateddigital.com/login/jquery-ui.js?v=0012

1/*! jQuery UI - v1.13.2 - 2023-11-19
2* http://jqueryui.com
3* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-patch.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/draggable.js, widgets/droppable.js, widgets/resizable.js, widgets/selectable.js, widgets/sortable.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, 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
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	 * jQuery UI Focusable 1.13.2
1331	 * http://jqueryui.com
1332	 *
1333	 * Copyright jQuery Foundation and other contributors
1334	 * Released under the MIT license.
1335	 * http://jquery.org/license
1336	 */
1337
1338	//>>label: :focusable Selector
1339	//>>group: Core
1340	//>>description: Selects elements which can be focused.
1341	//>>docs: http://api.jqueryui.com/focusable-selector/
1342
1343
1344	// Selectors
1345	$.ui.focusable = function (element, hasTabindex) {
1346		var map, mapName, img, focusableIfVisible, fieldset,
1347			nodeName = element.nodeName.toLowerCase();
1348
1349		if ("area" === nodeName) {
1350			map = element.parentNode;
1351			mapName = map.name;
1352			if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
1353				return false;
1354			}
1355			img = $("img[usemap='#" + mapName + "']");
1356			return img.length > 0 && img.is(":visible");
1357		}
1358
1359		if (/^(input|select|textarea|button|object)$/.test(nodeName)) {
1360			focusableIfVisible = !element.disabled;
1361
1362			if (focusableIfVisible) {
1363
1364				// Form controls within a disabled fieldset are disabled.
1365				// However, controls within the fieldset's legend do not get disabled.
1366				// Since controls generally aren't placed inside legends, we skip
1367				// this portion of the check.
1368				fieldset = $(element).closest("fieldset")[0];
1369				if (fieldset) {
1370					focusableIfVisible = !fieldset.disabled;
1371				}
1372			}
1373		} else if ("a" === nodeName) {
1374			focusableIfVisible = element.href || hasTabindex;
1375		} else {
1376			focusableIfVisible = hasTabindex;
1377		}
1378
1379		return focusableIfVisible && $(element).is(":visible") && visible($(element));
1380	};
1381
1382	// Support: IE 8 only
1383	// IE 8 doesn't resolve inherit to visible/hidden for computed values
1384	function visible(element) {
1385		var visibility = element.css("visibility");
1386		while (visibility === "inherit") {
1387			element = element.parent();
1388			visibility = element.css("visibility");
1389		}
1390		return visibility === "visible";
1391	}
1392
1393	$.extend($.expr.pseudos, {
1394		focusable: function (element) {
1395			return $.ui.focusable(element, $.attr(element, "tabindex") != null);
1396		}
1397	});
1398
1399	var focusable = $.ui.focusable;
1400
1401
1402
1403	// Support: IE8 Only
1404	// IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
1405	// with a string, so we need to find the proper form.
1406	var form = $.fn._form = function () {
1407		return typeof this[0].form === "string" ? this.closest("form") : $(this[0].form);
1408	};
1409
1410
1411	/*!
1412	 * jQuery UI Form Reset Mixin 1.13.2
1413	 * http://jqueryui.com
1414	 *
1415	 * Copyright jQuery Foundation and other contributors
1416	 * Released under the MIT license.
1417	 * http://jquery.org/license
1418	 */
1419
1420	//>>label: Form Reset Mixin
1421	//>>group: Core
1422	//>>description: Refresh input widgets when their form is reset
1423	//>>docs: http://api.jqueryui.com/form-reset-mixin/
1424
1425
1426	var formResetMixin = $.ui.formResetMixin = {
1427		_formResetHandler: function () {
1428			var form = $(this);
1429
1430			// Wait for the form reset to actually happen before refreshing
1431			setTimeout(function () {
1432				var instances = form.data("ui-form-reset-instances");
1433				$.each(instances, function () {
1434					this.refresh();
1435				});
1436			});
1437		},
1438
1439		_bindFormResetHandler: function () {
1440			this.form = this.element._form();
1441			if (!this.form.length) {
1442				return;
1443			}
1444
1445			var instances = this.form.data("ui-form-reset-instances") || [];
1446			if (!instances.length) {
1447
1448				// We don't use _on() here because we use a single event handler per form
1449				this.form.on("reset.ui-form-reset", this._formResetHandler);
1450			}
1451			instances.push(this);
1452			this.form.data("ui-form-reset-instances", instances);
1453		},
1454
1455		_unbindFormResetHandler: function () {
1456			if (!this.form.length) {
1457				return;
1458			}
1459
1460			var instances = this.form.data("ui-form-reset-instances");
1461			instances.splice($.inArray(this, instances), 1);
1462			if (instances.length) {
1463				this.form.data("ui-form-reset-instances", instances);
1464			} else {
1465				this.form
1466					.removeData("ui-form-reset-instances")
1467					.off("reset.ui-form-reset");
1468			}
1469		}
1470	};
1471
1472
1473	/*!
1474	 * jQuery UI Support for jQuery core 1.8.x and newer 1.13.2
1475	 * http://jqueryui.com
1476	 *
1477	 * Copyright jQuery Foundation and other contributors
1478	 * Released under the MIT license.
1479	 * http://jquery.org/license
1480	 *
1481	 */
1482
1483	//>>label: jQuery 1.8+ Support
1484	//>>group: Core
1485	//>>description: Support version 1.8.x and newer of jQuery core
1486
1487
1488	// Support: jQuery 1.9.x or older
1489	// $.expr[ ":" ] is deprecated.
1490	if (!$.expr.pseudos) {
1491		$.expr.pseudos = $.expr[":"];
1492	}
1493
1494	// Support: jQuery 1.11.x or older
1495	// $.unique has been renamed to $.uniqueSort
1496	if (!$.uniqueSort) {
1497		$.uniqueSort = $.unique;
1498	}
1499
1500	// Support: jQuery 2.2.x or older.
1501	// This method has been defined in jQuery 3.0.0.
1502	// Code from https://github.com/jquery/jquery/blob/e539bac79e666bba95bba86d690b4e609dca2286/src/selector/escapeSelector.js
1503	if (!$.escapeSelector) {
1504
1505		// CSS string/identifier serialization
1506		// https://drafts.csswg.org/cssom/#common-serializing-idioms
1507		var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
1508
1509		var fcssescape = function (ch, asCodePoint) {
1510			if (asCodePoint) {
1511
1512				// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
1513				if (ch === "\0") {
1514					return "\uFFFD";
1515				}
1516
1517				// Control characters and (dependent upon position) numbers get escaped as code points
1518				return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
1519			}
1520
1521			// Other potentially-special ASCII characters get backslash-escaped
1522			return "\\" + ch;
1523		};
1524
1525		$.escapeSelector = function (sel) {
1526			return (sel + "").replace(rcssescape, fcssescape);
1527		};
1528	}
1529
1530	// Support: jQuery 3.4.x or older
1531	// These methods have been defined in jQuery 3.5.0.
1532	if (!$.fn.even || !$.fn.odd) {
1533		$.fn.extend({
1534			even: function () {
1535				return this.filter(function (i) {
1536					return i % 2 === 0;
1537				});
1538			},
1539			odd: function () {
1540				return this.filter(function (i) {
1541					return i % 2 === 1;
1542				});
1543			}
1544		});
1545	}
1546
1547	;
1548	/*!
1549	 * jQuery UI Keycode 1.13.2
1550	 * http://jqueryui.com
1551	 *
1552	 * Copyright jQuery Foundation and other contributors
1553	 * Released under the MIT license.
1554	 * http://jquery.org/license
1555	 */
1556
1557	//>>label: Keycode
1558	//>>group: Core
1559	//>>description: Provide keycodes as keynames
1560	//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
1561
1562
1563	var keycode = $.ui.keyCode = {
1564		BACKSPACE: 8,
1565		COMMA: 188,
1566		DELETE: 46,
1567		DOWN: 40,
1568		END: 35,
1569		ENTER: 13,
1570		ESCAPE: 27,
1571		HOME: 36,
1572		LEFT: 37,
1573		PAGE_DOWN: 34,
1574		PAGE_UP: 33,
1575		PERIOD: 190,
1576		RIGHT: 39,
1577		SPACE: 32,
1578		TAB: 9,
1579		UP: 38
1580	};
1581
1582
1583	/*!
1584	 * jQuery UI Labels 1.13.2
1585	 * http://jqueryui.com
1586	 *
1587	 * Copyright jQuery Foundation and other contributors
1588	 * Released under the MIT license.
1589	 * http://jquery.org/license
1590	 */
1591
1592	//>>label: labels
1593	//>>group: Core
1594	//>>description: Find all the labels associated with a given input
1595	//>>docs: http://api.jqueryui.com/labels/
1596
1597
1598	var labels = $.fn.labels = function () {
1599		var ancestor, selector, id, labels, ancestors;
1600
1601		if (!this.length) {
1602			return this.pushStack([]);
1603		}
1604
1605		// Check control.labels first
1606		if (this[0].labels && this[0].labels.length) {
1607			return this.pushStack(this[0].labels);
1608		}
1609
1610		// Support: IE <= 11, FF <= 37, Android <= 2.3 only
1611		// Above browsers do not support control.labels. Everything below is to support them
1612		// as well as document fragments. control.labels does not work on document fragments
1613		labels = this.eq(0).parents("label");
1614
1615		// Look for the label based on the id
1616		id = this.attr("id");
1617		if (id) {
1618
1619			// We don't search against the document in case the element
1620			// is disconnected from the DOM
1621			ancestor = this.eq(0).parents().last();
1622
1623			// Get a full set of top level ancestors
1624			ancestors = ancestor.add(ancestor.length ? ancestor.siblings() : this.siblings());
1625
1626			// Create a selector for the label based on the id
1627			selector = "label[for='" + $.escapeSelector(id) + "']";
1628
1629			labels = labels.add(ancestors.find(selector).addBack(selector));
1630
1631		}
1632
1633		// Return whatever we have found for labels
1634		return this.pushStack(labels);
1635	};
1636
1637
1638	/*!
1639	 * jQuery UI Scroll Parent 1.13.2
1640	 * http://jqueryui.com
1641	 *
1642	 * Copyright jQuery Foundation and other contributors
1643	 * Released under the MIT license.
1644	 * http://jquery.org/license
1645	 */
1646
1647	//>>label: scrollParent
1648	//>>group: Core
1649	//>>description: Get the closest ancestor element that is scrollable.
1650	//>>docs: http://api.jqueryui.com/scrollParent/
1651
1652
1653	var scrollParent = $.fn.scrollParent = function (includeHidden) {
1654		var position = this.css("position"),
1655			excludeStaticParent = position === "absolute",
1656			overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
1657			scrollParent = this.parents().filter(function () {
1658				var parent = $(this);
1659				if (excludeStaticParent && parent.css("position") === "static") {
1660					return false;
1661				}
1662				return overflowRegex.test(parent.css("overflow") + parent.css("overflow-y") +
1663					parent.css("overflow-x"));
1664			}).eq(0);
1665
1666		return position === "fixed" || !scrollParent.length ?
1667			$(this[0].ownerDocument || document) :
1668			scrollParent;
1669	};
1670
1671
1672	/*!
1673	 * jQuery UI Tabbable 1.13.2
1674	 * http://jqueryui.com
1675	 *
1676	 * Copyright jQuery Foundation and other contributors
1677	 * Released under the MIT license.
1678	 * http://jquery.org/license
1679	 */
1680
1681	//>>label: :tabbable Selector
1682	//>>group: Core
1683	//>>description: Selects elements which can be tabbed to.
1684	//>>docs: http://api.jqueryui.com/tabbable-selector/
1685
1686
1687	var tabbable = $.extend($.expr.pseudos, {
1688		tabbable: function (element) {
1689			var tabIndex = $.attr(element, "tabindex"),
1690				hasTabindex = tabIndex != null;
1691			return (!hasTabindex || tabIndex >= 0) && $.ui.focusable(element, hasTabindex);
1692		}
1693	});
1694
1695
1696	/*!
1697	 * jQuery UI Unique ID 1.13.2
1698	 * http://jqueryui.com
1699	 *
1700	 * Copyright jQuery Foundation and other contributors
1701	 * Released under the MIT license.
1702	 * http://jquery.org/license
1703	 */
1704
1705	//>>label: uniqueId
1706	//>>group: Core
1707	//>>description: Functions to generate and remove uniqueId's
1708	//>>docs: http://api.jqueryui.com/uniqueId/
1709
1710
1711	var uniqueId = $.fn.extend({
1712		uniqueId: (function () {
1713			var uuid = 0;
1714
1715			return function () {
1716				return this.each(function () {
1717					if (!this.id) {
1718						this.id = "ui-id-" + (++uuid);
1719					}
1720				});
1721			};
1722		})(),
1723
1724		removeUniqueId: function () {
1725			return this.each(function () {
1726				if (/^ui-id-\d+$/.test(this.id)) {
1727					$(this).removeAttr("id");
1728				}
1729			});
1730		}
1731	});
1732
1733
1734
1735	// This file is deprecated
1736	var ie = $.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());
1737
1738	/*!
1739	 * jQuery UI Mouse 1.13.2
1740	 * http://jqueryui.com
1741	 *
1742	 * Copyright jQuery Foundation and other contributors
1743	 * Released under the MIT license.
1744	 * http://jquery.org/license
1745	 */
1746
1747	//>>label: Mouse
1748	//>>group: Widgets
1749	//>>description: Abstracts mouse-based interactions to assist in creating certain widgets.
1750	//>>docs: http://api.jqueryui.com/mouse/
1751
1752
1753	var mouseHandled = false;
1754	$(document).on("mouseup", function () {
1755		mouseHandled = false;
1756	});
1757
1758	var widgetsMouse = $.widget("ui.mouse", {
1759		version: "1.13.2",
1760		options: {
1761			cancel: "input, textarea, button, select, option",
1762			distance: 1,
1763			delay: 0
1764		},
1765		_mouseInit: function () {
1766			var that = this;
1767
1768			this.element
1769				.on("mousedown." + this.widgetName, function (event) {
1770					return that._mouseDown(event);
1771				})
1772				.on("click." + this.widgetName, function (event) {
1773					if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
1774						$.removeData(event.target, that.widgetName + ".preventClickEvent");
1775						event.stopImmediatePropagation();
1776						return false;
1777					}
1778				});
1779
1780			this.started = false;
1781		},
1782
1783		// TODO: make sure destroying one instance of mouse doesn't mess with
1784		// other instances of mouse
1785		_mouseDestroy: function () {
1786			this.element.off("." + this.widgetName);
1787			if (this._mouseMoveDelegate) {
1788				this.document
1789					.off("mousemove." + this.widgetName, this._mouseMoveDelegate)
1790					.off("mouseup." + this.widgetName, this._mouseUpDelegate);
1791			}
1792		},
1793
1794		_mouseDown: function (event) {
1795
1796			// don't let more than one widget handle mouseStart
1797			if (mouseHandled) {
1798				return;
1799			}
1800
1801			this._mouseMoved = false;
1802
1803			// We may have missed mouseup (out of window)
1804			if (this._mouseStarted) {
1805				this._mouseUp(event);
1806			}
1807
1808			this._mouseDownEvent = event;
1809
1810			var that = this,
1811				btnIsLeft = (event.which === 1),
1812
1813				// event.target.nodeName works around a bug in IE 8 with
1814				// disabled inputs (#7620)
1815				elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ?
1816					$(event.target).closest(this.options.cancel).length : false);
1817			if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
1818				return true;
1819			}
1820
1821			this.mouseDelayMet = !this.options.delay;
1822			if (!this.mouseDelayMet) {
1823				this._mouseDelayTimer = setTimeout(function () {
1824					that.mouseDelayMet = true;
1825				}, this.options.delay);
1826			}
1827
1828			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
1829				this._mouseStarted = (this._mouseStart(event) !== false);
1830				if (!this._mouseStarted) {
1831					event.preventDefault();
1832					return true;
1833				}
1834			}
1835
1836			// Click event may never have fired (Gecko & Opera)
1837			if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
1838				$.removeData(event.target, this.widgetName + ".preventClickEvent");
1839			}
1840
1841			// These delegates are required to keep context
1842			this._mouseMoveDelegate = function (event) {
1843				return that._mouseMove(event);
1844			};
1845			this._mouseUpDelegate = function (event) {
1846				return that._mouseUp(event);
1847			};
1848
1849			this.document
1850				.on("mousemove." + this.widgetName, this._mouseMoveDelegate)
1851				.on("mouseup." + this.widgetName, this._mouseUpDelegate);
1852
1853			event.preventDefault();
1854
1855			mouseHandled = true;
1856			return true;
1857		},
1858
1859		_mouseMove: function (event) {
1860
1861			// Only check for mouseups outside the document if you've moved inside the document
1862			// at least once. This prevents the firing of mouseup in the case of IE<9, which will
1863			// fire a mousemove event if content is placed under the cursor. See #7778
1864			// Support: IE <9
1865			if (this._mouseMoved) {
1866
1867				// IE mouseup check - mouseup happened when mouse was out of window
1868				if ($.ui.ie && (!document.documentMode || document.documentMode < 9) &&
1869					!event.button) {
1870					return this._mouseUp(event);
1871
1872					// Iframe mouseup check - mouseup occurred in another document
1873				} else if (!event.which) {
1874
1875					// Support: Safari <=8 - 9
1876					// Safari sets which to 0 if you press any of the following keys
1877					// during a drag (#14461)
1878					if (event.originalEvent.altKey || event.originalEvent.ctrlKey ||
1879						event.originalEvent.metaKey || event.originalEvent.shiftKey) {
1880						this.ignoreMissingWhich = true;
1881					} else if (!this.ignoreMissingWhich) {
1882						return this._mouseUp(event);
1883					}
1884				}
1885			}
1886
1887			if (event.which || event.button) {
1888				this._mouseMoved = true;
1889			}
1890
1891			if (this._mouseStarted) {
1892				this._mouseDrag(event);
1893				return event.preventDefault();
1894			}
1895
1896			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
1897				this._mouseStarted =
1898					(this._mouseStart(this._mouseDownEvent, event) !== false);
1899				if (this._mouseStarted) {
1900					this._mouseDrag(event);
1901				} else {
1902					this._mouseUp(event);
1903				}
1904			}
1905
1906			return !this._mouseStarted;
1907		},
1908
1909		_mouseUp: function (event) {
1910			this.document
1911				.off("mousemove." + this.widgetName, this._mouseMoveDelegate)
1912				.off("mouseup." + this.widgetName, this._mouseUpDelegate);
1913
1914			if (this._mouseStarted) {
1915				this._mouseStarted = false;
1916
1917				if (event.target === this._mouseDownEvent.target) {
1918					$.data(event.target, this.widgetName + ".preventClickEvent", true);
1919				}
1920
1921				this._mouseStop(event);
1922			}
1923
1924			if (this._mouseDelayTimer) {
1925				clearTimeout(this._mouseDelayTimer);
1926				delete this._mouseDelayTimer;
1927			}
1928
1929			this.ignoreMissingWhich = false;
1930			mouseHandled = false;
1931			event.preventDefault();
1932		},
1933
1934		_mouseDistanceMet: function (event) {
1935			return (Math.max(
1936				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1937				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1938			) >= this.options.distance
1939			);
1940		},
1941
1942		_mouseDelayMet: function ( /* event */) {
1943			return this.mouseDelayMet;
1944		},
1945
1946		// These are placeholder methods, to be overriden by extending plugin
1947		_mouseStart: function ( /* event */) { },
1948		_mouseDrag: function ( /* event */) { },
1949		_mouseStop: function ( /* event */) { },
1950		_mouseCapture: function ( /* event */) {
1951			return true;
1952		}
1953	});
1954
1955
1956
1957	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
1958	var plugin = $.ui.plugin = {
1959		add: function (module, option, set) {
1960			var i,
1961				proto = $.ui[module].prototype;
1962			for (i in set) {
1963				proto.plugins[i] = proto.plugins[i] || [];
1964				proto.plugins[i].push([option, set[i]]);
1965			}
1966		},
1967		call: function (instance, name, args, allowDisconnected) {
1968			var i,
1969				set = instance.plugins[name];
1970
1971			if (!set) {
1972				return;
1973			}
1974
1975			if (!allowDisconnected && (!instance.element[0].parentNode ||
1976				instance.element[0].parentNode.nodeType === 11)) {
1977				return;
1978			}
1979
1980			for (i = 0; i < set.length; i++) {
1981				if (instance.options[set[i][0]]) {
1982					set[i][1].apply(instance.element, args);
1983				}
1984			}
1985		}
1986	};
1987
1988
1989
1990	var safeActiveElement = $.ui.safeActiveElement = function (document) {
1991		var activeElement;
1992
1993		// Support: IE 9 only
1994		// IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
1995		try {
1996			activeElement = document.activeElement;
1997		} catch (error) {
1998			activeElement = document.body;
1999		}
2000
2001		// Support: IE 9 - 11 only
2002		// IE may return null instead of an element
2003		// Interestingly, this only seems to occur when NOT in an iframe
2004		if (!activeElement) {
2005			activeElement = document.body;
2006		}
2007
2008		// Support: IE 11 only
2009		// IE11 returns a seemingly empty object in some cases when accessing
2010		// document.activeElement from an <iframe>
2011		if (!activeElement.nodeName) {
2012			activeElement = document.body;
2013		}
2014
2015		return activeElement;
2016	};
2017
2018
2019
2020	var safeBlur = $.ui.safeBlur = function (element) {
2021
2022		// Support: IE9 - 10 only
2023		// If the <body> is blurred, IE will switch windows, see #9420
2024		if (element && element.nodeName.toLowerCase() !== "body") {
2025			$(element).trigger("blur");
2026		}
2027	};
2028
2029
2030	/*!
2031	 * jQuery UI Draggable 1.13.2
2032	 * http://jqueryui.com
2033	 *
2034	 * Copyright jQuery Foundation and other contributors
2035	 * Released under the MIT license.
2036	 * http://jquery.org/license
2037	 */
2038
2039	//>>label: Draggable
2040	//>>group: Interactions
2041	//>>description: Enables dragging functionality for any element.
2042	//>>docs: http://api.jqueryui.com/draggable/
2043	//>>demos: http://jqueryui.com/draggable/
2044	//>>css.structure: ../../themes/base/draggable.css
2045
2046
2047	$.widget("ui.draggable", $.ui.mouse, {
2048		version: "1.13.2",
2049		widgetEventPrefix: "drag",
2050		options: {
2051			addClasses: true,
2052			appendTo: "parent",
2053			axis: false,
2054			connectToSortable: false,
2055			containment: false,
2056			cursor: "auto",
2057			cursorAt: false,
2058			grid: false,
2059			handle: false,
2060			helper: "original",
2061			iframeFix: false,
2062			opacity: false,
2063			refreshPositions: false,
2064			revert: false,
2065			revertDuration: 500,
2066			scope: "default",
2067			scroll: true,
2068			scrollSensitivity: 20,
2069			scrollSpeed: 20,
2070			snap: false,
2071			snapMode: "both",
2072			snapTolerance: 20,
2073			stack: false,
2074			zIndex: false,
2075
2076			// Callbacks
2077			drag: null,
2078			start: null,
2079			stop: null
2080		},
2081		_create: function () {
2082
2083			if (this.options.helper === "original") {
2084				this._setPositionRelative();
2085			}
2086			if (this.options.addClasses) {
2087				this._addClass("ui-draggable");
2088			}
2089			this._setHandleClassName();
2090
2091			this._mouseInit();
2092		},
2093
2094		_setOption: function (key, value) {
2095			this._super(key, value);
2096			if (key === "handle") {
2097				this._removeHandleClassName();
2098				this._setHandleClassName();
2099			}
2100		},
2101
2102		_destroy: function () {
2103			if ((this.helper || this.element).is(".ui-draggable-dragging")) {
2104				this.destroyOnClear = true;
2105				return;
2106			}
2107			this._removeHandleClassName();
2108			this._mouseDestroy();
2109		},
2110
2111		_mouseCapture: function (event) {
2112			var o = this.options;
2113
2114			// Among others, prevent a drag on a resizable-handle
2115			if (this.helper || o.disabled ||
2116				$(event.target).closest(".ui-resizable-handle").length > 0) {
2117				return false;
2118			}
2119
2120			//Quit if we're not on a valid handle
2121			this.handle = this._getHandle(event);
2122			if (!this.handle) {
2123				return false;
2124			}
2125
2126			this._blurActiveElement(event);
2127
2128			this._blockFrames(o.iframeFix === true ? "iframe" : o.iframeFix);
2129
2130			return true;
2131
2132		},
2133
2134		_blockFrames: function (selector) {
2135			this.iframeBlocks = this.document.find(selector).map(function () {
2136				var iframe = $(this);
2137
2138				return $("<div>")
2139					.css("position", "absolute")
2140					.appendTo(iframe.parent())
2141					.outerWidth(iframe.outerWidth())
2142					.outerHeight(iframe.outerHeight())
2143					.offset(iframe.offset())[0];
2144			});
2145		},
2146
2147		_unblockFrames: function () {
2148			if (this.iframeBlocks) {
2149				this.iframeBlocks.remove();
2150				delete this.iframeBlocks;
2151			}
2152		},
2153
2154		_blurActiveElement: function (event) {
2155			var activeElement = $.ui.safeActiveElement(this.document[0]),
2156				target = $(event.target);
2157
2158			// Don't blur if the event occurred on an element that is within
2159			// the currently focused element
2160			// See #10527, #12472
2161			if (target.closest(activeElement).length) {
2162				return;
2163			}
2164
2165			// Blur any element that currently has focus, see #4261
2166			$.ui.safeBlur(activeElement);
2167		},
2168
2169		_mouseStart: function (event) {
2170
2171			var o = this.options;
2172
2173			//Create and append the visible helper
2174			this.helper = this._createHelper(event);
2175
2176			this._addClass(this.helper, "ui-draggable-dragging");
2177
2178			//Cache the helper size
2179			this._cacheHelperProportions();
2180
2181			//If ddmanager is used for droppables, set the global draggable
2182			if ($.ui.ddmanager) {
2183				$.ui.ddmanager.current = this;
2184			}
2185
2186			/*
2187			 * - Position generation -
2188			 * This block generates everything position related - it's the core of draggables.
2189			 */
2190
2191			//Cache the margins of the original element
2192			this._cacheMargins();
2193
2194			//Store the helper's css position
2195			this.cssPosition = this.helper.css("position");
2196			this.scrollParent = this.helper.scrollParent(true);
2197			this.offsetParent = this.helper.offsetParent();
2198			this.hasFixedAncestor = this.helper.parents().filter(function () {
2199				return $(this).css("position") === "fixed";
2200			}).length > 0;

2201
2202			//The element's absolute position on the page minus margins
2203			this.positionAbs = this.element.offset();
2204			this._refreshOffsets(event);
2205
2206			//Generate the original position
2207			this.originalPosition = this.position = this._generatePosition(event, false);
2208			this.originalPageX = event.pageX;
2209			this.originalPageY = event.pageY;
2210
2211			//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
2212			if (o.cursorAt) {
2213				this._adjustOffsetFromHelper(o.cursorAt);
2214			}
2215
2216			//Set a containment if given in the options
2217			this._setContainment();
2218
2219			//Trigger event + callbacks
2220			if (this._trigger("start", event) === false) {
2221				this._clear();
2222				return false;
2223			}
2224
2225			//Recache the helper size
2226			this._cacheHelperProportions();
2227
2228			//Prepare the droppable offsets
2229			if ($.ui.ddmanager && !o.dropBehaviour) {
2230				$.ui.ddmanager.prepareOffsets(this, event);
2231			}
2232
2233			// Execute the drag once - this causes the helper not to be visible before getting its
2234			// correct position
2235			this._mouseDrag(event, true);
2236
2237			// If the ddmanager is used for droppables, inform the manager that dragging has started
2238			// (see #5003)
2239			if ($.ui.ddmanager) {
2240				$.ui.ddmanager.dragStart(this, event);
2241			}
2242
2243			return true;
2244		},
2245
2246		_refreshOffsets: function (event) {
2247			this.offset = {
2248				top: this.positionAbs.top - this.margins.top,
2249				left: this.positionAbs.left - this.margins.left,
2250				scroll: false,
2251				parent: this._getParentOffset(),
2252				relative: this._getRelativeOffset()
2253			};
2254
2255			this.offset.click = {
2256				left: event.pageX - this.offset.left,
2257				top: event.pageY - this.offset.top
2258			};
2259		},
2260
2261		_mouseDrag: function (event, noPropagation) {
2262
2263			// reset any necessary cached properties (see #5009)
2264			if (this.hasFixedAncestor) {
2265				this.offset.parent = this._getParentOffset();
2266			}
2267
2268			//Compute the helpers position
2269			this.position = this._generatePosition(event, true);
2270			this.positionAbs = this._convertPositionTo("absolute");
2271
2272			//Call plugins and callbacks and use the resulting position if something is returned
2273			if (!noPropagation) {
2274				var ui = this._uiHash();
2275				if (this._trigger("drag", event, ui) === false) {
2276					this._mouseUp(new $.Event("mouseup", event));
2277					return false;
2278				}
2279				this.position = ui.position;
2280			}
2281
2282			this.helper[0].style.left = this.position.left + "px";
2283			this.helper[0].style.top = this.position.top + "px";
2284
2285			if ($.ui.ddmanager) {
2286				$.ui.ddmanager.drag(this, event);
2287			}
2288
2289			return false;
2290		},
2291
2292		_mouseStop: function (event) {
2293
2294			//If we are using droppables, inform the manager about the drop
2295			var that = this,
2296				dropped = false;
2297			if ($.ui.ddmanager && !this.options.dropBehaviour) {
2298				dropped = $.ui.ddmanager.drop(this, event);
2299			}
2300
2301			//if a drop comes from outside (a sortable)
2302			if (this.dropped) {
2303				dropped = this.dropped;
2304				this.dropped = false;
2305			}
2306
2307			if ((this.options.revert === "invalid" && !dropped) ||
2308				(this.options.revert === "valid" && dropped) ||
2309				this.options.revert === true || (typeof this.options.revert === "function" &&
2310					this.options.revert.call(this.element, dropped))
2311			) {
2312				$(this.helper).animate(
2313					this.originalPosition,
2314					parseInt(this.options.revertDuration, 10),
2315					function () {
2316						if (that._trigger("stop", event) !== false) {
2317							that._clear();
2318						}
2319					}
2320				);
2321			} else {
2322				if (this._trigger("stop", event) !== false) {
2323					this._clear();
2324				}
2325			}
2326
2327			return false;
2328		},
2329
2330		_mouseUp: function (event) {
2331			this._unblockFrames();
2332
2333			// If the ddmanager is used for droppables, inform the manager that dragging has stopped
2334			// (see #5003)
2335			if ($.ui.ddmanager) {
2336				$.ui.ddmanager.dragStop(this, event);
2337			}
2338
2339			// Only need to focus if the event occurred on the draggable itself, see #10527
2340			if (this.handleElement.is(event.target)) {
2341
2342				// The interaction is over; whether or not the click resulted in a drag,
2343				// focus the element
2344				this.element.trigger("focus");
2345			}
2346
2347			return $.ui.mouse.prototype._mouseUp.call(this, event);
2348		},
2349
2350		cancel: function () {
2351
2352			if (this.helper.is(".ui-draggable-dragging")) {
2353				this._mouseUp(new $.Event("mouseup", { target: this.element[0] }));
2354			} else {
2355				this._clear();
2356			}
2357
2358			return this;
2359
2360		},
2361
2362		_getHandle: function (event) {
2363			return this.options.handle ?
2364				!!$(event.target).closest(this.element.find(this.options.handle)).length :
2365				true;
2366		},
2367
2368		_setHandleClassName: function () {
2369			this.handleElement = this.options.handle ?
2370				this.element.find(this.options.handle) : this.element;
2371			this._addClass(this.handleElement, "ui-draggable-handle");
2372		},
2373
2374		_removeHandleClassName: function () {
2375			this._removeClass(this.handleElement, "ui-draggable-handle");
2376		},
2377
2378		_createHelper: function (event) {
2379
2380			var o = this.options,
2381				helperIsFunction = typeof o.helper === "function",
2382				helper = helperIsFunction ?
2383					$(o.helper.apply(this.element[0], [event])) :
2384					(o.helper === "clone" ?
2385						this.element.clone().removeAttr("id") :
2386						this.element);
2387
2388			if (!helper.parents("body").length) {
2389				helper.appendTo((o.appendTo === "parent" ?
2390					this.element[0].parentNode :
2391					o.appendTo));
2392			}
2393
2394			// Http://bugs.jqueryui.com/ticket/9446
2395			// a helper function can return the original element
2396			// which wouldn't have been set to relative in _create
2397			if (helperIsFunction && helper[0] === this.element[0]) {
2398				this._setPositionRelative();
2399			}
2400
2401			if (helper[0] !== this.element[0] &&
2402				!(/(fixed|absolute)/).test(helper.css("position"))) {
2403				helper.css("position", "absolute");
2404			}
2405
2406			return helper;
2407
2408		},
2409
2410		_setPositionRelative: function () {
2411			if (!(/^(?:r|a|f)/).test(this.element.css("position"))) {
2412				this.element[0].style.position = "relative";
2413			}
2414		},
2415
2416		_adjustOffsetFromHelper: function (obj) {
2417			if (typeof obj === "string") {
2418				obj = obj.split(" ");
2419			}
2420			if (Array.isArray(obj)) {
2421				obj = { left: +obj[0], top: +obj[1] || 0 };
2422			}
2423			if ("left" in obj) {
2424				this.offset.click.left = obj.left + this.margins.left;
2425			}
2426			if ("right" in obj) {
2427				this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
2428			}
2429			if ("top" in obj) {
2430				this.offset.click.top = obj.top + this.margins.top;
2431			}
2432			if ("bottom" in obj) {
2433				this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
2434			}
2435		},
2436
2437		_isRootNode: function (element) {
2438			return (/(html|body)/i).test(element.tagName) || element === this.document[0];
2439		},
2440
2441		_getParentOffset: function () {
2442
2443			//Get the offsetParent and cache its position
2444			var po = this.offsetParent.offset(),
2445				document = this.document[0];
2446
2447			// This is a special case where we need to modify a offset calculated on start, since the
2448			// following happened:
2449			// 1. The position of the helper is absolute, so it's position is calculated based on the
2450			// next positioned parent
2451			// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
2452			// the document, which means that the scroll is included in the initial calculation of the
2453			// offset of the parent, and never recalculated upon drag
2454			if (this.cssPosition === "absolute" && this.scrollParent[0] !== document &&
2455				$.contains(this.scrollParent[0], this.offsetParent[0])) {
2456				po.left += this.scrollParent.scrollLeft();
2457				po.top += this.scrollParent.scrollTop();
2458			}
2459
2460			if (this._isRootNode(this.offsetParent[0])) {
2461				po = { top: 0, left: 0 };
2462			}
2463
2464			return {
2465				top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
2466				left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
2467			};
2468
2469		},
2470
2471		_getRelativeOffset: function () {
2472			if (this.cssPosition !== "relative") {
2473				return { top: 0, left: 0 };
2474			}
2475
2476			var p = this.element.position(),
2477				scrollIsRootNode = this._isRootNode(this.scrollParent[0]);
2478
2479			return {
2480				top: p.top - (parseInt(this.helper.css("top"), 10) || 0) +
2481					(!scrollIsRootNode ? this.scrollParent.scrollTop() : 0),
2482				left: p.left - (parseInt(this.helper.css("left"), 10) || 0) +
2483					(!scrollIsRootNode ? this.scrollParent.scrollLeft() : 0)
2484			};
2485
2486		},
2487
2488		_cacheMargins: function () {
2489			this.margins = {
2490				left: (parseInt(this.element.css("marginLeft"), 10) || 0),
2491				top: (parseInt(this.element.css("marginTop"), 10) || 0),
2492				right: (parseInt(this.element.css("marginRight"), 10) || 0),
2493				bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
2494			};
2495		},
2496
2497		_cacheHelperProportions: function () {
2498			this.helperProportions = {
2499				width: this.helper.outerWidth(),
2500				height: this.helper.outerHeight()
2501			};
2502		},
2503
2504		_setContainment: function () {
2505
2506			var isUserScrollable, c, ce,
2507				o = this.options,
2508				document = this.document[0];
2509
2510			this.relativeContainer = null;
2511
2512			if (!o.containment) {
2513				this.containment = null;
2514				return;
2515			}
2516
2517			if (o.containment === "window") {
2518				this.containment = [
2519					$(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
2520					$(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,
2521					$(window).scrollLeft() + $(window).width() -
2522					this.helperProportions.width - this.margins.left,
2523					$(window).scrollTop() +
2524					($(window).height() || document.body.parentNode.scrollHeight) -
2525					this.helperProportions.height - this.margins.top
2526				];
2527				return;
2528			}
2529
2530			if (o.containment === "document") {
2531				this.containment = [
2532					0,
2533					0,
2534					$(document).width() - this.helperProportions.width - this.margins.left,
2535					($(document).height() || document.body.parentNode.scrollHeight) -
2536					this.helperProportions.height - this.margins.top
2537				];
2538				return;
2539			}
2540
2541			if (o.containment.constructor === Array) {
2542				this.containment = o.containment;
2543				return;
2544			}
2545
2546			if (o.containment === "parent") {
2547				o.containment = this.helper[0].parentNode;
2548			}
2549
2550			c = $(o.containment);
2551			ce = c[0];
2552
2553			if (!ce) {
2554				return;
2555			}
2556
2557			isUserScrollable = /(scroll|auto)/.test(c.css("overflow"));
2558
2559			this.containment = [
2560				(parseInt(c.css("borderLeftWidth"), 10) || 0) +
2561				(parseInt(c.css("paddingLeft"), 10) || 0),
2562				(parseInt(c.css("borderTopWidth"), 10) || 0) +
2563				(parseInt(c.css("paddingTop"), 10) || 0),
2564				(isUserScrollable ? Math.max(ce.scrollWidth, ce.offsetWidth) : ce.offsetWidth) -
2565				(parseInt(c.css("borderRightWidth"), 10) || 0) -
2566				(parseInt(c.css("paddingRight"), 10) || 0) -
2567				this.helperProportions.width -
2568				this.margins.left -
2569				this.margins.right,
2570				(isUserScrollable ? Math.max(ce.scrollHeight, ce.offsetHeight) : ce.offsetHeight) -
2571				(parseInt(c.css("borderBottomWidth"), 10) || 0) -
2572				(parseInt(c.css("paddingBottom"), 10) || 0) -
2573				this.helperProportions.height -
2574				this.margins.top -
2575				this.margins.bottom
2576			];
2577			this.relativeContainer = c;
2578		},
2579
2580		_convertPositionTo: function (d, pos) {
2581
2582			if (!pos) {
2583				pos = this.position;
2584			}
2585
2586			var mod = d === "absolute" ? 1 : -1,
2587				scrollIsRootNode = this._isRootNode(this.scrollParent[0]);
2588
2589			return {
2590				top: (
2591
2592					// The absolute mouse position
2593					pos.top +
2594
2595					// Only for relative positioned nodes: Relative offset from element to offset parent
2596					this.offset.relative.top * mod +
2597
2598					// The offsetParent's offset without borders (offset + border)
2599					this.offset.parent.top * mod -
2600					((this.cssPosition === "fixed" ?
2601						-this.offset.scroll.top :
2602						(scrollIsRootNode ? 0 : this.offset.scroll.top)) * mod)
2603				),
2604				left: (
2605
2606					// The absolute mouse position
2607					pos.left +
2608
2609					// Only for relative positioned nodes: Relative offset from element to offset parent
2610					this.offset.relative.left * mod +
2611
2612					// The offsetParent's offset without borders (offset + border)
2613					this.offset.parent.left * mod -
2614					((this.cssPosition === "fixed" ?
2615						-this.offset.scroll.left :
2616						(scrollIsRootNode ? 0 : this.offset.scroll.left)) * mod)
2617				)
2618			};
2619
2620		},
2621
2622		_generatePosition: function (event, constrainPosition) {
2623
2624			var containment, co, top, left,
2625				o = this.options,
2626				scrollIsRootNode = this._isRootNode(this.scrollParent[0]),
2627				pageX = event.pageX,
2628				pageY = event.pageY;
2629
2630			// Cache the scroll
2631			if (!scrollIsRootNode || !this.offset.scroll) {
2632				this.offset.scroll = {
2633					top: this.scrollParent.scrollTop(),
2634					left: this.scrollParent.scrollLeft()
2635				};
2636			}
2637
2638			/*
2639			 * - Position constraining -
2640			 * Constrain the position to a mix of grid, containment.
2641			 */
2642
2643			// If we are not dragging yet, we won't check for options
2644			if (constrainPosition) {
2645				if (this.containment) {
2646					if (this.relativeContainer) {
2647						co = this.relativeContainer.offset();
2648						containment = [
2649							this.containment[0] + co.left,
2650							this.containment[1] + co.top,
2651							this.containment[2] + co.left,
2652							this.containment[3] + co.top
2653						];
2654					} else {
2655						containment = this.containment;
2656					}
2657
2658					if (event.pageX - this.offset.click.left < containment[0]) {
2659						pageX = containment[0] + this.offset.click.left;
2660					}
2661					if (event.pageY - this.offset.click.top < containment[1]) {
2662						pageY = containment[1] + this.offset.click.top;
2663					}
2664					if (event.pageX - this.offset.click.left > containment[2]) {
2665						pageX = containment[2] + this.offset.click.left;
2666					}
2667					if (event.pageY - this.offset.click.top > containment[3]) {
2668						pageY = containment[3] + this.offset.click.top;
2669					}
2670				}
2671
2672				if (o.grid) {
2673
2674					//Check for grid elements set to 0 to prevent divide by 0 error causing invalid
2675					// argument errors in IE (see ticket #6950)
2676					top = o.grid[1] ? this.originalPageY + Math.round((pageY -
2677						this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
2678					pageY = containment ? ((top - this.offset.click.top >= containment[1] ||
2679						top - this.offset.click.top > containment[3]) ?
2680						top :
2681						((top - this.offset.click.top >= containment[1]) ?
2682							top - o.grid[1] : top + o.grid[1])) : top;
2683
2684					left = o.grid[0] ? this.originalPageX +
2685						Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] :
2686						this.originalPageX;
2687					pageX = containment ? ((left - this.offset.click.left >= containment[0] ||
2688						left - this.offset.click.left > containment[2]) ?
2689						left :
2690						((left - this.offset.click.left >= containment[0]) ?
2691							left - o.grid[0] : left + o.grid[0])) : left;
2692				}
2693
2694				if (o.axis === "y") {
2695					pageX = this.originalPageX;
2696				}
2697
2698				if (o.axis === "x") {
2699					pageY = this.originalPageY;
2700				}
2701			}
2702
2703			return {
2704				top: (
2705
2706					// The absolute mouse position
2707					pageY -
2708
2709					// Click offset (relative to the element)
2710					this.offset.click.top -
2711
2712					// Only for relative positioned nodes: Relative offset from element to offset parent
2713					this.offset.relative.top -
2714
2715					// The offsetParent's offset without borders (offset + border)
2716					this.offset.parent.top +
2717					(this.cssPosition === "fixed" ?
2718						-this.offset.scroll.top :
2719						(scrollIsRootNode ? 0 : this.offset.scroll.top))
2720				),
2721				left: (
2722
2723					// The absolute mouse position
2724					pageX -
2725
2726					// Click offset (relative to the element)
2727					this.offset.click.left -
2728
2729					// Only for relative positioned nodes: Relative offset from element to offset parent
2730					this.offset.relative.left -
2731
2732					// The offsetParent's offset without borders (offset + border)
2733					this.offset.parent.left +
2734					(this.cssPosition === "fixed" ?
2735						-this.offset.scroll.left :
2736						(scrollIsRootNode ? 0 : this.offset.scroll.left))
2737				)
2738			};
2739
2740		},
2741
2742		_clear: function () {
2743			this._removeClass(this.helper, "ui-draggable-dragging");
2744			if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
2745				this.helper.remove();
2746			}
2747			this.helper = null;
2748			this.cancelHelperRemoval = false;
2749			if (this.destroyOnClear) {
2750				this.destroy();
2751			}
2752		},
2753
2754		// From now on bulk stuff - mainly helpers
2755
2756		_trigger: function (type, event, ui) {
2757			ui = ui || this._uiHash();
2758			$.ui.plugin.call(this, type, [event, ui, this], true);
2759
2760			// Absolute position and offset (see #6884 ) have to be recalculated after plugins
2761			if (/^(drag|start|stop)/.test(type)) {
2762				this.positionAbs = this._convertPositionTo("absolute");
2763				ui.offset = this.positionAbs;
2764			}
2765			return $.Widget.prototype._trigger.call(this, type, event, ui);
2766		},
2767
2768		plugins: {},
2769
2770		_uiHash: function () {
2771			return {
2772				helper: this.helper,
2773				position: this.position,
2774				originalPosition: this.originalPosition,
2775				offset: this.positionAbs
2776			};
2777		}
2778
2779	});
2780
2781	$.ui.plugin.add("draggable", "connectToSortable", {
2782		start: function (event, ui, draggable) {
2783			var uiSortable = $.extend({}, ui, {
2784				item: draggable.element
2785			});
2786
2787			draggable.sortables = [];
2788			$(draggable.options.connectToSortable).each(function () {
2789				var sortable = $(this).sortable("instance");
2790
2791				if (sortable && !sortable.options.disabled) {
2792					draggable.sortables.push(sortable);
2793
2794					// RefreshPositions is called at drag start to refresh the containerCache
2795					// which is used in drag. This ensures it's initialized and synchronized
2796					// with any changes that might have happened on the page since initialization.
2797					sortable.refreshPositions();
2798					sortable._trigger("activate", event, uiSortable);
2799				}
2800			});
2801		},
2802		stop: function (event, ui, draggable) {
2803			var uiSortable = $.extend({}, ui, {
2804				item: draggable.element
2805			});
2806
2807			draggable.cancelHelperRemoval = false;
2808
2809			$.each(draggable.sortables, function () {
2810				var sortable = this;
2811
2812				if (sortable.isOver) {
2813					sortable.isOver = 0;
2814
2815					// Allow this sortable to handle removing the helper
2816					draggable.cancelHelperRemoval = true;
2817					sortable.cancelHelperRemoval = false;
2818
2819					// Use _storedCSS To restore properties in the sortable,
2820					// as this also handles revert (#9675) since the draggable
2821					// may have modified them in unexpected ways (#8809)
2822					sortable._storedCSS = {
2823						position: sortable.placeholder.css("position"),
2824						top: sortable.placeholder.css("top"),
2825						left: sortable.placeholder.css("left")
2826					};
2827
2828					sortable._mouseStop(event);
2829
2830					// Once drag has ended, the sortable should return to using
2831					// its original helper, not the shared helper from draggable
2832					sortable.options.helper = sortable.options._helper;
2833				} else {
2834
2835					// Prevent this Sortable from removing the helper.
2836					// However, don't set the draggable to remove the helper
2837					// either as another connected Sortable may yet handle the removal.
2838					sortable.cancelHelperRemoval = true;
2839
2840					sortable._trigger("deactivate", event, uiSortable);
2841				}
2842			});
2843		},
2844		drag: function (event, ui, draggable) {
2845			$.each(draggable.sortables, function () {
2846				var innermostIntersecting = false,
2847					sortable = this;
2848
2849				// Copy over variables that sortable's _intersectsWith uses
2850				sortable.positionAbs = draggable.positionAbs;
2851				sortable.helperProportions = draggable.helperProportions;
2852				sortable.offset.click = draggable.offset.click;
2853
2854				if (sortable._intersectsWith(sortable.containerCache)) {
2855					innermostIntersecting = true;
2856
2857					$.each(draggable.sortables, function () {
2858
2859						// Copy over variables that sortable's _intersectsWith uses
2860						this.positionAbs = draggable.positionAbs;
2861						this.helperProportions = draggable.helperProportions;
2862						this.offset.click = draggable.offset.click;
2863
2864						if (this !== sortable &&
2865							this._intersectsWith(this.containerCache) &&
2866							$.contains(sortable.element[0], this.element[0])) {
2867							innermostIntersecting = false;
2868						}
2869
2870						return innermostIntersecting;
2871					});
2872				}
2873
2874				if (innermostIntersecting) {
2875
2876					// If it intersects, we use a little isOver variable and set it once,
2877					// so that the move-in stuff gets fired only once.
2878					if (!sortable.isOver) {
2879						sortable.isOver = 1;
2880
2881						// Store draggable's parent in case we need to reappend to it later.
2882						draggable._parent = ui.helper.parent();
2883
2884						sortable.currentItem = ui.helper
2885							.appendTo(sortable.element)
2886							.data("ui-sortable-item", true);
2887
2888						// Store helper option to later restore it
2889						sortable.options._helper = sortable.options.helper;
2890
2891						sortable.options.helper = function () {
2892							return ui.helper[0];
2893						};
2894
2895						// Fire the start events of the sortable with our passed browser event,
2896						// and our own helper (so it doesn't create a new one)
2897						event.target = sortable.currentItem[0];
2898						sortable._mouseCapture(event, true);
2899						sortable._mouseStart(event, true, true);
2900
2901						// Because the browser event is way off the new appended portlet,
2902						// modify necessary variables to reflect the changes
2903						sortable.offset.click.top = draggable.offset.click.top;
2904						sortable.offset.click.left = draggable.offset.click.left;
2905						sortable.offset.parent.left -= draggable.offset.parent.left -
2906							sortable.offset.parent.left;
2907						sortable.offset.parent.top -= draggable.offset.parent.top -
2908							sortable.offset.parent.top;
2909
2910						draggable._trigger("toSortable", event);
2911
2912						// Inform draggable that the helper is in a valid drop zone,
2913						// used solely in the revert option to handle "valid/invalid".
2914						draggable.dropped = sortable.element;
2915
2916						// Need to refreshPositions of all sortables in the case that
2917						// adding to one sortable changes the location of the other sortables (#9675)
2918						$.each(draggable.sortables, function () {
2919							this.refreshPositions();
2920						});
2921
2922						// Hack so receive/update callbacks work (mostly)
2923						draggable.currentItem = draggable.element;
2924						sortable.fromOutside = draggable;
2925					}
2926
2927					if (sortable.currentItem) {
2928						sortable._mouseDrag(event);
2929
2930						// Copy the sortable's position because the draggable's can potentially reflect
2931						// a relative position, while sortable is always absolute, which the dragged
2932						// element has now become. (#8809)
2933						ui.position = sortable.position;
2934					}
2935				} else {
2936
2937					// If it doesn't intersect with the sortable, and it intersected before,
2938					// we fake the drag stop of the sortable, but make sure it doesn't remove
2939					// the helper by using cancelHelperRemoval.
2940					if (sortable.isOver) {
2941
2942						sortable.isOver = 0;
2943						sortable.cancelHelperRemoval = true;
2944
2945						// Calling sortable's mouseStop would trigger a revert,
2946						// so revert must be temporarily false until after mouseStop is called.
2947						sortable.options._revert = sortable.options.revert;
2948						sortable.options.revert = false;
2949
2950						sortable._trigger("out", event, sortable._uiHash(sortable));
2951						sortable._mouseStop(event, true);
2952
2953						// Restore sortable behaviors that were modfied
2954						// when the draggable entered the sortable area (#9481)
2955						sortable.options.revert = sortable.options._revert;
2956						sortable.options.helper = sortable.options._helper;
2957
2958						if (sortable.placeholder) {
2959							sortable.placeholder.remove();
2960						}
2961
2962						// Restore and recalculate the draggable's offset considering the sortable
2963						// may have modified them in unexpected ways. (#8809, #10669)
2964						ui.helper.appendTo(draggable._parent);
2965						draggable._refreshOffsets(event);
2966						ui.position = draggable._generatePosition(event, true);
2967
2968						draggable._trigger("fromSortable", event);
2969
2970						// Inform draggable that the helper is no longer in a valid drop zone
2971						draggable.dropped = false;
2972
2973						// Need to refreshPositions of all sortables just in case removing
2974						// from one sortable changes the location of other sortables (#9675)
2975						$.each(draggable.sortables, function () {
2976							this.refreshPositions();
2977						});
2978					}
2979				}
2980			});
2981		}
2982	});
2983
2984	$.ui.plugin.add("draggable", "cursor", {
2985		start: function (event, ui, instance) {
2986			var t = $("body"),
2987				o = instance.options;
2988
2989			if (t.css("cursor")) {
2990				o._cursor = t.css("cursor");
2991			}
2992			t.css("cursor", o.cursor);
2993		},
2994		stop: function (event, ui, instance) {
2995			var o = instance.options;
2996			if (o._cursor) {
2997				$("body").css("cursor", o._cursor);
2998			}
2999		}
3000	});
3001
3002	$.ui.plugin.add("draggable", "opacity", {
3003		start: function (event, ui, instance) {
3004			var t = $(ui.helper),
3005				o = instance.options;
3006			if (t.css("opacity")) {
3007				o._opacity = t.css("opacity");
3008			}
3009			t.css("opacity", o.opacity);
3010		},
3011		stop: function (event, ui, instance) {
3012			var o = instance.options;
3013			if (o._opacity) {
3014				$(ui.helper).css("opacity", o._opacity);
3015			}
3016		}
3017	});
3018
3019	$.ui.plugin.add("draggable", "scroll", {
3020		start: function (event, ui, i) {
3021			if (!i.scrollParentNotHidden) {
3022				i.scrollParentNotHidden = i.helper.scrollParent(false);
3023			}
3024
3025			if (i.scrollParentNotHidden[0] !== i.document[0] &&
3026				i.scrollParentNotHidden[0].tagName !== "HTML") {
3027				i.overflowOffset = i.scrollParentNotHidden.offset();
3028			}
3029		},
3030		drag: function (event, ui, i) {
3031
3032			var o = i.options,
3033				scrolled = false,
3034				scrollParent = i.scrollParentNotHidden[0],
3035				document = i.document[0];
3036
3037			if (scrollParent !== document && scrollParent.tagName !== "HTML") {
3038				if (!o.axis || o.axis !== "x") {
3039					if ((i.overflowOffset.top + scrollParent.offsetHeight) - event.pageY <
3040						o.scrollSensitivity) {
3041						scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
3042					} else if (event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
3043						scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
3044					}
3045				}
3046
3047				if (!o.axis || o.axis !== "y") {
3048					if ((i.overflowOffset.left + scrollParent.offsetWidth) - event.pageX <
3049						o.scrollSensitivity) {
3050						scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
3051					} else if (event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
3052						scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
3053					}
3054				}
3055
3056			} else {
3057
3058				if (!o.axis || o.axis !== "x") {
3059					if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
3060						scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
3061					} else if ($(window).height() - (event.pageY - $(document).scrollTop()) <
3062						o.scrollSensitivity) {
3063						scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
3064					}
3065				}
3066
3067				if (!o.axis || o.axis !== "y") {
3068					if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
3069						scrolled = $(document).scrollLeft(
3070							$(document).scrollLeft() - o.scrollSpeed
3071						);
3072					} else if ($(window).width() - (event.pageX - $(document).scrollLeft()) <
3073						o.scrollSensitivity) {
3074						scrolled = $(document).scrollLeft(
3075							$(document).scrollLeft() + o.scrollSpeed
3076						);
3077					}
3078				}
3079
3080			}
3081
3082			if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
3083				$.ui.ddmanager.prepareOffsets(i, event);
3084			}
3085
3086		}
3087	});
3088
3089	$.ui.plugin.add("draggable", "snap", {
3090		start: function (event, ui, i) {
3091
3092			var o = i.options;
3093
3094			i.snapElements = [];
3095
3096			$(o.snap.constructor !== String ? (o.snap.items || ":data(ui-draggable)") : o.snap)
3097				.each(function () {
3098					var $t = $(this),
3099						$o = $t.offset();
3100					if (this !== i.element[0]) {
3101						i.snapElements.push({
3102							item: this,
3103							width: $t.outerWidth(), height: $t.outerHeight(),
3104							top: $o.top, left: $o.left
3105						});
3106					}
3107				});
3108
3109		},
3110		drag: function (event, ui, inst) {
3111
3112			var ts, bs, ls, rs, l, r, t, b, i, first,
3113				o = inst.options,
3114				d = o.snapTolerance,
3115				x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
3116				y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
3117
3118			for (i = inst.snapElements.length - 1; i >= 0; i--) {
3119
3120				l = inst.snapElements[i].left - inst.margins.left;
3121				r = l + inst.snapElements[i].width;
3122				t = inst.snapElements[i].top - inst.margins.top;
3123				b = t + inst.snapElements[i].height;
3124
3125				if (x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d ||
3126					!$.contains(inst.snapElements[i].item.ownerDocument,
3127						inst.snapElements[i].item)) {
3128					if (inst.snapElements[i].snapping) {
3129						if (inst.options.snap.release) {
3130							inst.options.snap.release.call(
3131								inst.element,
3132								event,
3133								$.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })
3134							);
3135						}
3136					}
3137					inst.snapElements[i].snapping = false;
3138					continue;
3139				}
3140
3141				if (o.snapMode !== "inner") {
3142					ts = Math.abs(t - y2) <= d;
3143					bs = Math.abs(b - y1) <= d;
3144					ls = Math.abs(l - x2) <= d;
3145					rs = Math.abs(r - x1) <= d;
3146					if (ts) {
3147						ui.position.top = inst._convertPositionTo("relative", {
3148							top: t - inst.helperProportions.height,
3149							left: 0
3150						}).top;
3151					}
3152					if (bs) {
3153						ui.position.top = inst._convertPositionTo("relative", {
3154							top: b,
3155							left: 0
3156						}).top;
3157					}
3158					if (ls) {
3159						ui.position.left = inst._convertPositionTo("relative", {
3160							top: 0,
3161							left: l - inst.helperProportions.width
3162						}).left;
3163					}
3164					if (rs) {
3165						ui.position.left = inst._convertPositionTo("relative", {
3166							top: 0,
3167							left: r
3168						}).left;
3169					}
3170				}
3171
3172				first = (ts || bs || ls || rs);
3173
3174				if (o.snapMode !== "outer") {
3175					ts = Math.abs(t - y1) <= d;
3176					bs = Math.abs(b - y2) <= d;
3177					ls = Math.abs(l - x1) <= d;
3178					rs = Math.abs(r - x2) <= d;
3179					if (ts) {
3180						ui.position.top = inst._convertPositionTo("relative", {
3181							top: t,
3182							left: 0
3183						}).top;
3184					}
3185					if (bs) {
3186						ui.position.top = inst._convertPositionTo("relative", {
3187							top: b - inst.helperProportions.height,
3188							left: 0
3189						}).top;
3190					}
3191					if (ls) {
3192						ui.position.left = inst._convertPositionTo("relative", {
3193							top: 0,
3194							left: l
3195						}).left;
3196					}
3197					if (rs) {
3198						ui.position.left = inst._convertPositionTo("relative", {
3199							top: 0,
3200							left: r - inst.helperProportions.width
3201						}).left;
3202					}
3203				}
3204
3205				if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
3206					if (inst.options.snap.snap) {
3207						inst.options.snap.snap.call(
3208							inst.element,
3209							event,
3210							$.extend(inst._uiHash(), {
3211								snapItem: inst.snapElements[i].item
3212							}));
3213					}
3214				}
3215				inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
3216
3217			}
3218
3219		}
3220	});
3221
3222	$.ui.plugin.add("draggable", "stack", {
3223		start: function (event, ui, instance) {
3224			var min,
3225				o = instance.options,
3226				group = $.makeArray($(o.stack)).sort(function (a, b) {
3227					return (parseInt($(a).css("zIndex"), 10) || 0) -
3228						(parseInt($(b).css("zIndex"), 10) || 0);
3229				});
3230
3231			if (!group.length) {
3232				return;
3233			}
3234
3235			min = parseInt($(group[0]).css("zIndex"), 10) || 0;
3236			$(group).each(function (i) {
3237				$(this).css("zIndex", min + i);
3238			});
3239			this.css("zIndex", (min + group.length));
3240		}
3241	});
3242
3243	$.ui.plugin.add("draggable", "zIndex", {
3244		start: function (event, ui, instance) {
3245			var t = $(ui.helper),
3246				o = instance.options;
3247
3248			if (t.css("zIndex")) {
3249				o._zIndex = t.css("zIndex");
3250			}
3251			t.css("zIndex", o.zIndex);
3252		},
3253		stop: function (event, ui, instance) {
3254			var o = instance.options;
3255
3256			if (o._zIndex) {
3257				$(ui.helper).css("zIndex", o._zIndex);
3258			}
3259		}
3260	});
3261
3262	var widgetsDraggable = $.ui.draggable;
3263
3264
3265	/*!
3266	 * jQuery UI Droppable 1.13.2
3267	 * http://jqueryui.com
3268	 *
3269	 * Copyright jQuery Foundation and other contributors
3270	 * Released under the MIT license.
3271	 * http://jquery.org/license
3272	 */
3273
3274	//>>label: Droppable
3275	//>>group: Interactions
3276	//>>description: Enables drop targets for draggable elements.
3277	//>>docs: http://api.jqueryui.com/droppable/
3278	//>>demos: http://jqueryui.com/droppable/
3279
3280
3281	$.widget("ui.droppable", {
3282		version: "1.13.2",
3283		widgetEventPrefix: "drop",
3284		options: {
3285			accept: "*",
3286			addClasses: true,
3287			greedy: false,
3288			scope: "default",
3289			tolerance: "intersect",
3290
3291			// Callbacks
3292			activate: null,
3293			deactivate: null,
3294			drop: null,
3295			out: null,
3296			over: null
3297		},
3298		_create: function () {
3299
3300			var proportions,
3301				o = this.options,
3302				accept = o.accept;
3303
3304			this.isover = false;
3305			this.isout = true;
3306
3307			this.accept = typeof accept === "function" ? accept : function (d) {
3308				return d.is(accept);
3309			};
3310
3311			this.proportions = function ( /* valueToWrite */) {
3312				if (arguments.length) {
3313
3314					// Store the droppable's proportions
3315					proportions = arguments[0];
3316				} else {
3317
3318					// Retrieve or derive the droppable's proportions
3319					return proportions ?
3320						proportions :
3321						proportions = {
3322							width: this.element[0].offsetWidth,
3323							height: this.element[0].offsetHeight
3324						};
3325				}
3326			};
3327
3328			this._addToManager(o.scope);
3329
3330			if (o.addClasses) {
3331				this._addClass("ui-droppable");
3332			}
3333
3334		},
3335
3336		_addToManager: function (scope) {
3337
3338			// Add the reference and positions to the manager
3339			$.ui.ddmanager.droppables[scope] = $.ui.ddmanager.droppables[scope] || [];
3340			$.ui.ddmanager.droppables[scope].push(this);
3341		},
3342
3343		_splice: function (drop) {
3344			var i = 0;
3345			for (; i < drop.length; i++) {
3346				if (drop[i] === this) {
3347					drop.splice(i, 1);
3348				}
3349			}
3350		},
3351
3352		_destroy: function () {
3353			var drop = $.ui.ddmanager.droppables[this.options.scope];
3354
3355			this._splice(drop);
3356		},
3357
3358		_setOption: function (key, value) {
3359
3360			if (key === "accept") {
3361				this.accept = typeof value === "function" ? value : function (d) {
3362					return d.is(value);
3363				};
3364			} else if (key === "scope") {
3365				var drop = $.ui.ddmanager.droppables[this.options.scope];
3366
3367				this._splice(drop);
3368				this._addToManager(value);
3369			}
3370
3371			this._super(key, value);
3372		},
3373
3374		_activate: function (event) {
3375			var draggable = $.ui.ddmanager.current;
3376
3377			this._addActiveClass();
3378			if (draggable) {
3379				this._trigger("activate", event, this.ui(draggable));
3380			}
3381		},
3382
3383		_deactivate: function (event) {
3384			var draggable = $.ui.ddmanager.current;
3385
3386			this._removeActiveClass();
3387			if (draggable) {
3388				this._trigger("deactivate", event, this.ui(draggable));
3389			}
3390		},
3391
3392		_over: function (event) {
3393
3394			var draggable = $.ui.ddmanager.current;
3395
3396			// Bail if draggable and droppable are same element
3397			if (!draggable || (draggable.currentItem ||
3398				draggable.element)[0] === this.element[0]) {
3399				return;
3400			}
3401
3402			if (this.accept.call(this.element[0], (draggable.currentItem ||
3403				draggable.element))) {
3404				this._addHoverClass();
3405				this._trigger("over", event, this.ui(draggable));
3406			}
3407
3408		},
3409
3410		_out: function (event) {
3411
3412			var draggable = $.ui.ddmanager.current;
3413
3414			// Bail if draggable and droppable are same element
3415			if (!draggable || (draggable.currentItem ||
3416				draggable.element)[0] === this.element[0]) {
3417				return;
3418			}
3419
3420			if (this.accept.call(this.element[0], (draggable.currentItem ||
3421				draggable.element))) {
3422				this._removeHoverClass();
3423				this._trigger("out", event, this.ui(draggable));
3424			}
3425
3426		},
3427
3428		_drop: function (event, custom) {
3429
3430			var draggable = custom || $.ui.ddmanager.current,
3431				childrenIntersection = false;
3432
3433			// Bail if draggable and droppable are same element
3434			if (!draggable || (draggable.currentItem ||
3435				draggable.element)[0] === this.element[0]) {
3436				return false;
3437			}
3438
3439			this.element
3440				.find(":data(ui-droppable)")
3441				.not(".ui-draggable-dragging")
3442				.each(function () {
3443					var inst = $(this).droppable("instance");
3444					if (
3445						inst.options.greedy &&
3446						!inst.options.disabled &&
3447						inst.options.scope === draggable.options.scope &&
3448						inst.accept.call(
3449							inst.element[0], (draggable.currentItem || draggable.element)
3450						) &&
3451						$.ui.intersect(
3452							draggable,
3453							$.extend(inst, { offset: inst.element.offset() }),
3454							inst.options.tolerance, event
3455						)
3456					) {
3457						childrenIntersection = true;
3458						return false;
3459					}
3460				});
3461			if (childrenIntersection) {
3462				return false;
3463			}
3464
3465			if (this.accept.call(this.element[0],
3466				(draggable.currentItem || draggable.element))) {
3467				this._removeActiveClass();
3468				this._removeHoverClass();
3469
3470				this._trigger("drop", event, this.ui(draggable));
3471				return this.element;
3472			}
3473
3474			return false;
3475
3476		},
3477
3478		ui: function (c) {
3479			return {
3480				draggable: (c.currentItem || c.element),
3481				helper: c.helper,
3482				position: c.position,
3483				offset: c.positionAbs
3484			};
3485		},
3486
3487		// Extension points just to make backcompat sane and avoid duplicating logic
3488		// TODO: Remove in 1.14 along with call to it below
3489		_addHoverClass: function () {
3490			this._addClass("ui-droppable-hover");
3491		},
3492
3493		_removeHoverClass: function () {
3494			this._removeClass("ui-droppable-hover");
3495		},
3496
3497		_addActiveClass: function () {
3498			this._addClass("ui-droppable-active");
3499		},
3500
3501		_removeActiveClass: function () {
3502			this._removeClass("ui-droppable-active");
3503		}
3504	});
3505
3506	$.ui.intersect = (function () {
3507		function isOverAxis(x, reference, size) {
3508			return (x >= reference) && (x < (reference + size));
3509		}
3510
3511		return function (draggable, droppable, toleranceMode, event) {
3512
3513			if (!droppable.offset) {
3514				return false;
3515			}
3516
3517			var x1 = (draggable.positionAbs ||
3518				draggable.position.absolute).left + draggable.margins.left,
3519				y1 = (draggable.positionAbs ||
3520					draggable.position.absolute).top + draggable.margins.top,
3521				x2 = x1 + draggable.helperProportions.width,
3522				y2 = y1 + draggable.helperProportions.height,
3523				l = droppable.offset.left,
3524				t = droppable.offset.top,
3525				r = l + droppable.proportions().width,
3526				b = t + droppable.proportions().height;
3527
3528			switch (toleranceMode) {
3529				case "fit":
3530					return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
3531				case "intersect":
3532					return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
3533						x2 - (draggable.helperProportions.width / 2) < r && // Left Half
3534						t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
3535						y2 - (draggable.helperProportions.height / 2) < b); // Top Half
3536				case "pointer":
3537					return isOverAxis(event.pageY, t, droppable.proportions().height) &&
3538						isOverAxis(event.pageX, l, droppable.proportions().width);
3539				case "touch":
3540					return (
3541						(y1 >= t && y1 <= b) || // Top edge touching
3542						(y2 >= t && y2 <= b) || // Bottom edge touching
3543						(y1 < t && y2 > b) // Surrounded vertically
3544					) && (
3545							(x1 >= l && x1 <= r) || // Left edge touching
3546							(x2 >= l && x2 <= r) || // Right edge touching
3547							(x1 < l && x2 > r) // Surrounded horizontally
3548						);
3549				default:
3550					return false;
3551			}
3552		};
3553	})();
3554
3555	/*
3556		This manager tracks offsets of draggables and droppables
3557	*/
3558	$.ui.ddmanager = {
3559		current: null,
3560		droppables: { "default": [] },
3561		prepareOffsets: function (t, event) {
3562
3563			var i, j,
3564				m = $.ui.ddmanager.droppables[t.options.scope] || [],
3565				type = event ? event.type : null, // workaround for #2317
3566				list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
3567
3568			droppablesLoop: for (i = 0; i < m.length; i++) {
3569
3570				// No disabled and non-accepted
3571				if (m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],
3572					(t.currentItem || t.element)))) {
3573					continue;
3574				}
3575
3576				// Filter out elements in the current dragged item
3577				for (j = 0; j < list.length; j++) {
3578					if (list[j] === m[i].element[0]) {
3579						m[i].proportions().height = 0;
3580						continue droppablesLoop;
3581					}
3582				}
3583
3584				m[i].visible = m[i].element.css("display") !== "none";
3585				if (!m[i].visible) {
3586					continue;
3587				}
3588
3589				// Activate the droppable if used directly from draggables
3590				if (type === "mousedown") {
3591					m[i]._activate.call(m[i], event);
3592				}
3593
3594				m[i].offset = m[i].element.offset();
3595				m[i].proportions({
3596					width: m[i].element[0].offsetWidth,
3597					height: m[i].element[0].offsetHeight
3598				});
3599
3600			}
3601
3602		},
3603		drop: function (draggable, event) {
3604
3605			var dropped = false;
3606
3607			// Create a copy of the droppables in case the list changes during the drop (#9116)