/*!

 * jQuery UI Sortable 1.13.3

 * https://jqueryui.com

 *

 * Copyright OpenJS Foundation and other contributors

 * Released under the MIT license.

 * https://jquery.org/license

 */

//>>label: Sortable

//>>group: Interactions

//>>description: Enables items in a list to be sorted using the mouse.

//>>docs: https://api.jqueryui.com/sortable/

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

//>>css.structure: ../../themes/base/sortable.css

( function( factory ) {

	"use strict";

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

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./mouse",

			"../data",

			"../ie",

			"../scroll-parent",

			"../version",

			"../widget"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

return $.widget( "ui.sortable", $.ui.mouse, {

	version: "1.13.3",

	widgetEventPrefix: "sort",

	ready: false,

	options: {

		appendTo: "parent",

		axis: false,

		connectWith: false,

		containment: false,

		cursor: "auto",

		cursorAt: false,

		dropOnEmpty: true,

		forcePlaceholderSize: false,

		forceHelperSize: false,

		grid: false,

		handle: false,

		helper: "original",

		items: "> *",

		opacity: false,

		placeholder: false,

		revert: false,

		scroll: true,

		scrollSensitivity: 20,

		scrollSpeed: 20,

		scope: "default",

		tolerance: "intersect",

		zIndex: 1000,

		// Callbacks

		activate: null,

		beforeStop: null,

		change: null,

		deactivate: null,

		out: null,

		over: null,

		receive: null,

		remove: null,

		sort: null,

		start: null,

		stop: null,

		update: null

	},

	_isOverAxis: function( x, reference, size ) {

		return ( x >= reference ) && ( x < ( reference + size ) );

	},

	_isFloating: function( item ) {

		return ( /left|right/ ).test( item.css( "float" ) ) ||

			( /inline|table-cell/ ).test( item.css( "display" ) );

	},

	_create: function() {

		this.containerCache = {};

		this._addClass( "ui-sortable" );

		//Get the items

		this.refresh();

		//Let's determine the parent's offset

		this.offset = this.element.offset();

		//Initialize mouse events for interaction

		this._mouseInit();

		this._setHandleClassName();

		//We're ready to go

		this.ready = true;

	},

	_setOption: function( key, value ) {

		this._super( key, value );

		if ( key === "handle" ) {

			this._setHandleClassName();

		}

	},

	_setHandleClassName: function() {

		var that = this;

		this._removeClass( this.element.find( ".ui-sortable-handle" ), "ui-sortable-handle" );

		$.each( this.items, function() {

			that._addClass(

				this.instance.options.handle ?

					this.item.find( this.instance.options.handle ) :

					this.item,

				"ui-sortable-handle"

			);

		} );

	},

	_destroy: function() {

		this._mouseDestroy();

		for ( var i = this.items.length - 1; i >= 0; i-- ) {

			this.items[ i ].item.removeData( this.widgetName + "-item" );

		}

		return this;

	},

	_mouseCapture: function( event, overrideHandle ) {

		var currentItem = null,

			validHandle = false,

			that = this;

		if ( this.reverting ) {

			return false;

		}

		if ( this.options.disabled || this.options.type === "static" ) {

			return false;

		}

		//We have to refresh the items data once first

		this._refreshItems( event );

		//Find out if the clicked node (or one of its parents) is a actual item in this.items

		$( event.target ).parents().each( function() {

			if ( $.data( this, that.widgetName + "-item" ) === that ) {

				currentItem = $( this );

				return false;

			}

		} );

		if ( $.data( event.target, that.widgetName + "-item" ) === that ) {

			currentItem = $( event.target );

		}

		if ( !currentItem ) {

			return false;

		}

		if ( this.options.handle && !overrideHandle ) {

			$( this.options.handle, currentItem ).find( "*" ).addBack().each( function() {

				if ( this === event.target ) {

					validHandle = true;

				}

			} );

			if ( !validHandle ) {

				return false;

			}

		}

		this.currentItem = currentItem;

		this._removeCurrentsFromItems();

		return true;

	},

	_mouseStart: function( event, overrideHandle, noActivation ) {

		var i, body,

			o = this.options;

		this.currentContainer = this;

		//We only need to call refreshPositions, because the refreshItems call has been moved to

		// mouseCapture

		this.refreshPositions();

		//Prepare the dragged items parent

		this.appendTo = $( o.appendTo !== "parent" ?

				o.appendTo :

				this.currentItem.parent() );

		//Create and append the visible helper

		this.helper = this._createHelper( event );

		//Cache the helper size

		this._cacheHelperProportions();

		/*

		 * - Position generation -

		 * This block generates everything position related - it's the core of draggables.

		 */

		//Cache the margins of the original element

		this._cacheMargins();

		//The element's absolute position on the page minus margins

		this.offset = this.currentItem.offset();

		this.offset = {

			top: this.offset.top - this.margins.top,

			left: this.offset.left - this.margins.left

		};

		$.extend( this.offset, {

			click: { //Where the click happened, relative to the element

				left: event.pageX - this.offset.left,

				top: event.pageY - this.offset.top

			},

			// This is a relative to absolute position minus the actual position calculation -

			// only used for relative positioned helper

			relative: this._getRelativeOffset()

		} );

		// After we get the helper offset, but before we get the parent offset we can

		// change the helper's position to absolute

		// TODO: Still need to figure out a way to make relative sorting possible

		this.helper.css( "position", "absolute" );

		this.cssPosition = this.helper.css( "position" );

		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied

		if ( o.cursorAt ) {

			this._adjustOffsetFromHelper( o.cursorAt );

		}

		//Cache the former DOM position

		this.domPosition = {

			prev: this.currentItem.prev()[ 0 ],

			parent: this.currentItem.parent()[ 0 ]

		};

		// If the helper is not the original, hide the original so it's not playing any role during

		// the drag, won't cause anything bad this way

		if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {

			this.currentItem.hide();

		}

		//Create the placeholder

		this._createPlaceholder();

		//Get the next scrolling parent

		this.scrollParent = this.placeholder.scrollParent();

		$.extend( this.offset, {

			parent: this._getParentOffset()

		} );

		//Set a containment if given in the options

		if ( o.containment ) {

			this._setContainment();

		}

		if ( o.cursor && o.cursor !== "auto" ) { // cursor option

			body = this.document.find( "body" );

			// Support: IE

			this.storedCursor = body.css( "cursor" );

			body.css( "cursor", o.cursor );

			this.storedStylesheet =

				$( "<style>*{ cursor: " + o.cursor + " !important; }</style>" ).appendTo( body );

		}

		// We need to make sure to grab the zIndex before setting the

		// opacity, because setting the opacity to anything lower than 1

		// causes the zIndex to change from "auto" to 0.

		if ( o.zIndex ) { // zIndex option

			if ( this.helper.css( "zIndex" ) ) {

				this._storedZIndex = this.helper.css( "zIndex" );

			}

			this.helper.css( "zIndex", o.zIndex );

		}

		if ( o.opacity ) { // opacity option

			if ( this.helper.css( "opacity" ) ) {

				this._storedOpacity = this.helper.css( "opacity" );

			}

			this.helper.css( "opacity", o.opacity );

		}

		//Prepare scrolling

		if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&

				this.scrollParent[ 0 ].tagName !== "HTML" ) {

			this.overflowOffset = this.scrollParent.offset();

		}

		//Call callbacks

		this._trigger( "start", event, this._uiHash() );

		//Recache the helper size

		if ( !this._preserveHelperProportions ) {

			this._cacheHelperProportions();

		}

		//Post "activate" events to possible containers

		if ( !noActivation ) {

			for ( i = this.containers.length - 1; i >= 0; i-- ) {

				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );

			}

		}

		//Prepare possible droppables

		if ( $.ui.ddmanager ) {

			$.ui.ddmanager.current = this;

		}

		if ( $.ui.ddmanager && !o.dropBehaviour ) {

			$.ui.ddmanager.prepareOffsets( this, event );

		}

		this.dragging = true;

		this._addClass( this.helper, "ui-sortable-helper" );

		//Move the helper, if needed

		if ( !this.helper.parent().is( this.appendTo ) ) {

			this.helper.detach().appendTo( this.appendTo );

			//Update position

			this.offset.parent = this._getParentOffset();

		}

		//Generate the original position

		this.position = this.originalPosition = this._generatePosition( event );

		this.originalPageX = event.pageX;

		this.originalPageY = event.pageY;

		this.lastPositionAbs = this.positionAbs = this._convertPositionTo( "absolute" );

		this._mouseDrag( event );

		return true;

	},

	_scroll: function( event ) {

		var o = this.options,

			scrolled = false;

		if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&

				this.scrollParent[ 0 ].tagName !== "HTML" ) {

			if ( ( this.overflowOffset.top + this.scrollParent[ 0 ].offsetHeight ) -