{“ast”:null,“code”:“function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }nn/**!n * Sortable 1.10.0n * @authortRubaXa <trash@rubaxa.org>n * @authortowenm <owen23355@gmail.com>n * @license MITn */nfunction _typeof(obj) {n if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {n _typeof = function _typeof(obj) {n return _typeof2(obj);n };n } else {n _typeof = function _typeof(obj) {n return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);n };n }nn return _typeof(obj);n}nnfunction _defineProperty(obj, key, value) {n if (key in obj) {n Object.defineProperty(obj, key, {n value: value,n enumerable: true,n configurable: true,n writable: truen });n } else {n obj = value;n }nn return obj;n}nnfunction _extends() {n _extends = Object.assign || function (target) {n for (var i = 1; i < arguments.length; i++) {n var source = arguments;nn for (var key in source) {n if (Object.prototype.hasOwnProperty.call(source, key)) {n target = source;n }n }n }nn return target;n };nn return _extends.apply(this, arguments);n}nnfunction _objectSpread(target) {n for (var i = 1; i < arguments.length; i++) {n var source = arguments != null ? arguments : {};n var ownKeys = Object.keys(source);nn if (typeof Object.getOwnPropertySymbols === 'function') {n ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {n return Object.getOwnPropertyDescriptor(source, sym).enumerable;n }));n }nn ownKeys.forEach(function (key) {n _defineProperty(target, key, source);n });n }nn return target;n}nnfunction _objectWithoutPropertiesLoose(source, excluded) {n if (source == null) return {};n var target = {};n var sourceKeys = Object.keys(source);n var key, i;nn for (i = 0; i < sourceKeys.length; i++) {n key = sourceKeys;n if (excluded.indexOf(key) >= 0) continue;n target = source;n }nn return target;n}nnfunction _objectWithoutProperties(source, excluded) {n if (source == null) return {};nn var target = _objectWithoutPropertiesLoose(source, excluded);nn var key, i;nn if (Object.getOwnPropertySymbols) {n var sourceSymbolKeys = Object.getOwnPropertySymbols(source);nn for (i = 0; i < sourceSymbolKeys.length; i++) {n key = sourceSymbolKeys;n if (excluded.indexOf(key) >= 0) continue;n if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;n target = source;n }n }nn return target;n}nnfunction _toConsumableArray(arr) {n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();n}nnfunction _arrayWithoutHoles(arr) {n if (Array.isArray(arr)) {n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {n arr2 = arr;n }nn return arr2;n }n}nnfunction _iterableToArray(iter) {n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);n}nnfunction _nonIterableSpread() {n throw new TypeError("Invalid attempt to spread non-iterable instance");n}nnvar version = "1.10.0";nnfunction userAgent(pattern) {n return !!n /*@__PURE__*/n navigator.userAgent.match(pattern);n}nnvar IE11OrLess = userAgent(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i);nvar Edge = userAgent(/Edge/i);nvar FireFox = userAgent(/firefox/i);nvar Safari = userAgent(/safari/i) && !userAgent(/chrome/i) && !userAgent(/android/i);nvar IOS = userAgent(/iP(ad|od|hone)/i);nvar ChromeForAndroid = userAgent(/chrome/i) && userAgent(/android/i);nvar captureMode = {n capture: false,n passive: falsen};nnfunction on(el, event, fn) {n el.addEventListener(event, fn, !IE11OrLess && captureMode);n}nnfunction off(el, event, fn) {n el.removeEventListener(event, fn, !IE11OrLess && captureMode);n}nnfunction matches(n/*HTMLElement/nel,n/*String/nselector) {n if (!selector) return;n selector === '>' && (selector = selector.substring(1));nn if (el) {n try {n if (el.matches) {n return el.matches(selector);n } else if (el.msMatchesSelector) {n return el.msMatchesSelector(selector);n } else if (el.webkitMatchesSelector) {n return el.webkitMatchesSelector(selector);n }n } catch (_) {n return false;n }n }nn return false;n}nnfunction getParentOrHost(el) {n return el.host && el !== document && el.host.nodeType ? el.host : el.parentNode;n}nnfunction closest(n/*HTMLElement/nel,n/*String/nselector,n/*HTMLElement/nctx, includeCTX) {n if (el) {n ctx = ctx || document;nn do {n if (selector != null && (selector === '>' ? el.parentNode === ctx && matches(el, selector) : matches(el, selector)) || includeCTX && el === ctx) {n return el;n }nn if (el === ctx) break;n /* jshint boss:true */n } while (el = getParentOrHost(el));n }nn return null;n}nnvar R_SPACE = /\s+/g;nnfunction toggleClass(el, name, state) {n if (el && name) {n if (el.classList) {n el.classList[state ? 'add' : 'remove'](name);n } else {n var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' ');n el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' ');n }n }n}nnfunction css(el, prop, val) {n var style = el && el.style;nn if (style) {n if (val === void 0) {n if (document.defaultView && document.defaultView.getComputedStyle) {n val = document.defaultView.getComputedStyle(el, '');n } else if (el.currentStyle) {n val = el.currentStyle;n }nn return prop === void 0 ? val : val;n } else {n if (!(prop in style) && prop.indexOf('webkit') === -1) {n prop = '-webkit-' + prop;n }nn style = val + (typeof val === 'string' ? '' : 'px');n }n }n}nnfunction matrix(el, selfOnly) {n var appliedTransforms = '';nn if (typeof el === 'string') {n appliedTransforms = el;n } else {n do {n var transform = css(el, 'transform');nn if (transform && transform !== 'none') {n appliedTransforms = transform + ' ' + appliedTransforms;n }n /* jshint boss:true */nn } while (!selfOnly && (el = el.parentNode));n }nn var matrixFn = window.DOMMatrix || window.WebKitCSSMatrix || window.CSSMatrix;n /*jshint -W056 */nn return matrixFn && new matrixFn(appliedTransforms);n}nnfunction find(ctx, tagName, iterator) {n if (ctx) {n var list = ctx.getElementsByTagName(tagName),n i = 0,n n = list.length;nn if (iterator) {n for (; i < n; i++) {n iterator(list, i);n }n }nn return list;n }nn return [];n}nnfunction getWindowScrollingElement() {n if (IE11OrLess) {n return document.documentElement;n } else {n return document.scrollingElement;n }n}n/**n * Returns the "bounding client rect" of given elementn * @param {HTMLElement} el The element whose boundingClientRect is wantedn * @param {[Boolean]} relativeToContainingBlock Whether the rect should be relative to the containing block of (including) the containern * @param {[Boolean]} relativeToNonStaticParent Whether the rect should be relative to the relative parent of (including) the contaienrn * @param {[Boolean]} undoScale Whether the container's scale() should be undonen * @param {[HTMLElement]} container The parent the element will be placed inn * @return {Object} The boundingClientRect of el, with specified adjustmentsn */nnnfunction getRect(el, relativeToContainingBlock, relativeToNonStaticParent, undoScale, container) {n if (!el.getBoundingClientRect && el !== window) return;n var elRect, top, left, bottom, right, height, width;nn if (el !== window && el !== getWindowScrollingElement()) {n elRect = el.getBoundingClientRect();n top = elRect.top;n left = elRect.left;n bottom = elRect.bottom;n right = elRect.right;n height = elRect.height;n width = elRect.width;n } else {n top = 0;n left = 0;n bottom = window.innerHeight;n right = window.innerWidth;n height = window.innerHeight;n width = window.innerWidth;n }nn if ((relativeToContainingBlock || relativeToNonStaticParent) && el !== window) {n // Adjust for translate()n container = container || el.parentNode; // solves #1123 (see: stackoverflow.com/a/37953806/6088312)n // Not needed on <= IE11nn if (!IE11OrLess) {n do {n if (container && container.getBoundingClientRect && (css(container, 'transform') !== 'none' || relativeToNonStaticParent && css(container, 'position') !== 'static')) {n var containerRect = container.getBoundingClientRect(); // Set relative to edges of padding box of containernn top -= containerRect.top + parseInt(css(container, 'border-top-width'));n left -= containerRect.left + parseInt(css(container, 'border-left-width'));n bottom = top + elRect.height;n right = left + elRect.width;n break;n }n /* jshint boss:true */nn } while (container = container.parentNode);n }n }nn if (undoScale && el !== window) {n // Adjust for scale()n var elMatrix = matrix(container || el),n scaleX = elMatrix && elMatrix.a,n scaleY = elMatrix && elMatrix.d;nn if (elMatrix) {n top /= scaleY;n left /= scaleX;n width /= scaleX;n height /= scaleY;n bottom = top + height;n right = left + width;n }n }nn return {n top: top,n left: left,n bottom: bottom,n right: right,n width: width,n height: heightn };n}n/**n * Checks if a side of an element is scrolled past a side of its parentsn * @param {HTMLElement} el The element who's side being scrolled out of view is in questionn * @param {String} elSide Side of the element in question ('top', 'left', 'right', 'bottom')n * @param {String} parentSide Side of the parent in question ('top', 'left', 'right', 'bottom')n * @return {HTMLElement} The parent scroll element that the el's side is scrolled past, or null if there is no such elementn */nnnfunction isScrolledPast(el, elSide, parentSide) {n var parent = getParentAutoScrollElement(el, true),n elSideVal = getRect(el);n /* jshint boss:true */nn while (parent) {n var parentSideVal = getRect(parent),n visible = void 0;nn if (parentSide === 'top' || parentSide === 'left') {n visible = elSideVal >= parentSideVal;n } else {n visible = elSideVal <= parentSideVal;n }nn if (!visible) return parent;n if (parent === getWindowScrollingElement()) break;n parent = getParentAutoScrollElement(parent, false);n }nn return false;n}n/**n * Gets nth child of el, ignoring hidden children, sortable's elements (does not ignore clone if it's visible)n * and non-draggable elementsn * @param {HTMLElement} el The parent elementn * @param {Number} childNum The index of the childn * @param {Object} options Parent Sortable's optionsn * @return {HTMLElement} The child at index childNum, or null if not foundn */nnnfunction getChild(el, childNum, options) {n var currentChild = 0,n i = 0,n children = el.children;nn while (i < children.length) {n if (children.style.display !== 'none' && children !== Sortable.ghost && children !== Sortable.dragged && closest(children, options.draggable, el, false)) {n if (currentChild === childNum) {n return children;n }nn currentChild++;n }nn i++;n }nn return null;n}n/**n * Gets the last child in the el, ignoring ghostEl or invisible elements (clones)n * @param {HTMLElement} el Parent elementn * @param {selector} selector Any other elements that should be ignoredn * @return {HTMLElement} The last child, ignoring ghostEln */nnnfunction lastChild(el, selector) {n var last = el.lastElementChild;nn while (last && (last === Sortable.ghost || css(last, 'display') === 'none' || selector && !matches(last, selector))) {n last = last.previousElementSibling;n }nn return last || null;n}n/**n * Returns the index of an element within its parent for a selected set ofn * elementsn * @param {HTMLElement} eln * @param {selector} selectorn * @return {number}n */nnnfunction index(el, selector) {n var index = 0;nn if (!el || !el.parentNode) {n return -1;n }n /* jshint boss:true */nnn while (el = el.previousElementSibling) {n if (el.nodeName.toUpperCase() !== 'TEMPLATE' && el !== Sortable.clone && (!selector || matches(el, selector))) {n index++;n }n }nn return index;n}n/**n * Returns the scroll offset of the given element, added with all the scroll offsets of parent elements.n * The value is returned in real pixels.n * @param {HTMLElement} eln * @return {Array} Offsets in the format of [left, top]n */nnnfunction getRelativeScrollOffset(el) {n var offsetLeft = 0,n offsetTop = 0,n winScroller = getWindowScrollingElement();nn if (el) {n do {n var elMatrix = matrix(el),n scaleX = elMatrix.a,n scaleY = elMatrix.d;n offsetLeft += el.scrollLeft * scaleX;n offsetTop += el.scrollTop * scaleY;n } while (el !== winScroller && (el = el.parentNode));n }nn return [offsetLeft, offsetTop];n}n/**n * Returns the index of the object within the given arrayn * @param {Array} arr Array that may or may not hold the objectn * @param {Object} obj An object that has a key-value pair unique to and identical to a key-value pair in the object you want to findn * @return {Number} The index of the object in the array, or -1n */nnnfunction indexOfObject(arr, obj) {n for (var i in arr) {n if (!arr.hasOwnProperty(i)) continue;nn for (var key in obj) {n if (obj.hasOwnProperty(key) && obj === arr[key]) return Number(i);n }n }nn return -1;n}nnfunction getParentAutoScrollElement(el, includeSelf) {n // skip to windown if (!el || !el.getBoundingClientRect) return getWindowScrollingElement();n var elem = el;n var gotSelf = false;nn do {n // we don't need to get elem css if it isn't even overflowing in the first place (performance)n if (elem.clientWidth < elem.scrollWidth || elem.clientHeight < elem.scrollHeight) {n var elemCSS = css(elem);nn if (elem.clientWidth < elem.scrollWidth && (elemCSS.overflowX == 'auto' || elemCSS.overflowX == 'scroll') || elem.clientHeight < elem.scrollHeight && (elemCSS.overflowY == 'auto' || elemCSS.overflowY == 'scroll')) {n if (!elem.getBoundingClientRect || elem === document.body) return getWindowScrollingElement();n if (gotSelf || includeSelf) return elem;n gotSelf = true;n }n }n /* jshint boss:true */nn } while (elem = elem.parentNode);nn return getWindowScrollingElement();n}nnfunction extend(dst, src) {n if (dst && src) {n for (var key in src) {n if (src.hasOwnProperty(key)) {n dst = src;n }n }n }nn return dst;n}nnfunction isRectEqual(rect1, rect2) {n return Math.round(rect1.top) === Math.round(rect2.top) && Math.round(rect1.left) === Math.round(rect2.left) && Math.round(rect1.height) === Math.round(rect2.height) && Math.round(rect1.width) === Math.round(rect2.width);n}nnvar _throttleTimeout;nnfunction throttle(callback, ms) {n return function () {n if (!_throttleTimeout) {n var args = arguments,n _this = this;nn if (args.length === 1) {n callback.call(_this, args);n } else {n callback.apply(_this, args);n }nn _throttleTimeout = setTimeout(function () {n _throttleTimeout = void 0;n }, ms);n }n };n}nnfunction cancelThrottle() {n clearTimeout(_throttleTimeout);n _throttleTimeout = void 0;n}nnfunction scrollBy(el, x, y) {n el.scrollLeft += x;n el.scrollTop += y;n}nnfunction clone(el) {n var Polymer = window.Polymer;n var $ = window.jQuery || window.Zepto;nn if (Polymer && Polymer.dom) {n return Polymer.dom(el).cloneNode(true);n } else if ($) {n return $(el).clone(true);n } else {n return el.cloneNode(true);n }n}nnfunction setRect(el, rect) {n css(el, 'position', 'absolute');n css(el, 'top', rect.top);n css(el, 'left', rect.left);n css(el, 'width', rect.width);n css(el, 'height', rect.height);n}nnfunction unsetRect(el) {n css(el, 'position', '');n css(el, 'top', '');n css(el, 'left', '');n css(el, 'width', '');n css(el, 'height', '');n}nnvar expando = 'Sortable' + new Date().getTime();nnfunction AnimationStateManager() {n var animationStates = [],n animationCallbackId;n return {n captureAnimationState: function captureAnimationState() {n animationStates = [];n if (!this.options.animation) return;n var children = [].slice.call(this.el.children);n children.forEach(function (child) {n if (css(child, 'display') === 'none' || child === Sortable.ghost) return;n animationStates.push({n target: child,n rect: getRect(child)n });nn var fromRect = _objectSpread({}, animationStates[animationStates.length - 1].rect); // If animating: compensate for current animationnnn if (child.thisAnimationDuration) {n var childMatrix = matrix(child, true);nn if (childMatrix) {n fromRect.top -= childMatrix.f;n fromRect.left -= childMatrix.e;n }n }nn child.fromRect = fromRect;n });n },n addAnimationState: function addAnimationState(state) {n animationStates.push(state);n },n removeAnimationState: function removeAnimationState(target) {n animationStates.splice(indexOfObject(animationStates, {n target: targetn }), 1);n },n animateAll: function animateAll(callback) {n var _this = this;nn if (!this.options.animation) {n clearTimeout(animationCallbackId);n if (typeof callback === 'function') callback();n return;n }nn var animating = false,n animationTime = 0;n animationStates.forEach(function (state) {n var time = 0,n target = state.target,n fromRect = target.fromRect,n toRect = getRect(target),n prevFromRect = target.prevFromRect,n prevToRect = target.prevToRect,n animatingRect = state.rect,n targetMatrix = matrix(target, true);nn if (targetMatrix) {n // Compensate for current animationn toRect.top -= targetMatrix.f;n toRect.left -= targetMatrix.e;n }nn target.toRect = toRect;nn if (target.thisAnimationDuration) {n // Could also check if animatingRect is between fromRect and toRectn if (isRectEqual(prevFromRect, toRect) && !isRectEqual(fromRect, toRect) && // Make
sure animatingRect is on line between toRect & fromRectn (animatingRect.top - toRect.top) / (animatingRect.left - toRect.left) === (fromRect.top - toRect.top) / (fromRect.left - toRect.left)) {n // If returning to same place as started from animation and on same axisn time = calculateRealTime(animatingRect, prevFromRect, prevToRect, _this.options);n }n } // if fromRect != toRect: animatennn if (!isRectEqual(toRect, fromRect)) {n target.prevFromRect = fromRect;n target.prevToRect = toRect;nn if (!time) {n time = _this.options.animation;n }nn _this.animate(target, animatingRect, toRect, time);n }nn if (time) {n animating = true;n animationTime = Math.max(animationTime, time);n clearTimeout(target.animationResetTimer);n target.animationResetTimer = setTimeout(function () {n target.animationTime = 0;n target.prevFromRect = null;n target.fromRect = null;n target.prevToRect = null;n target.thisAnimationDuration = null;n }, time);n target.thisAnimationDuration = time;n }n });n clearTimeout(animationCallbackId);nn if (!animating) {n if (typeof callback === 'function') callback();n } else {n animationCallbackId = setTimeout(function () {n if (typeof callback === 'function') callback();n }, animationTime);n }nn animationStates = [];n },n animate: function animate(target, currentRect, toRect, duration) {n if (duration) {n css(target, 'transition', '');n css(target, 'transform', '');n var elMatrix = matrix(this.el),n scaleX = elMatrix && elMatrix.a,n scaleY = elMatrix && elMatrix.d,n translateX = (currentRect.left - toRect.left) / (scaleX || 1),n translateY = (currentRect.top - toRect.top) / (scaleY || 1);n target.animatingX = !!translateX;n target.animatingY = !!translateY;n css(target, 'transform', 'translate3d(' + translateX + 'px,' + translateY + 'px,0)');n repaint(target); // repaintnn css(target, 'transition', 'transform ' + duration + 'ms' + (this.options.easing ? ' ' + this.options.easing : ''));n css(target, 'transform', 'translate3d(0,0,0)');n typeof target.animated === 'number' && clearTimeout(target.animated);n target.animated = setTimeout(function () {n css(target, 'transition', '');n css(target, 'transform', '');n target.animated = false;n target.animatingX = false;n target.animatingY = false;n }, duration);n }n }n };n}nnfunction repaint(target) {n return target.offsetWidth;n}nnfunction calculateRealTime(animatingRect, fromRect, toRect, options) {n return Math.sqrt(Math.pow(fromRect.top - animatingRect.top, 2) + Math.pow(fromRect.left - animatingRect.left, 2)) / Math.sqrt(Math.pow(fromRect.top - toRect.top, 2) + Math.pow(fromRect.left - toRect.left, 2)) * options.animation;n}nnvar plugins = [];nvar defaults = {n initializeByDefault: truen};nvar PluginManager = {n mount: function mount(plugin) {n // Set default static propertiesn for (var option in defaults) {n if (defaults.hasOwnProperty(option) && !(option in plugin)) {n plugin = defaults;n }n }nn plugins.push(plugin);n },n pluginEvent: function pluginEvent(eventName, sortable, evt) {n var _this = this;nn this.eventCanceled = false;nn evt.cancel = function () {n _this.eventCanceled = true;n };nn var eventNameGlobal = eventName + 'Global';n plugins.forEach(function (plugin) {n if (!sortable) return; // Fire global events if it exists in this sortablenn if (sortable[eventNameGlobal]) {n sortable[eventNameGlobal](_objectSpread({n sortable: sortablen }, evt));n } // Only fire plugin event if plugin is enabled in this sortable,n // and plugin has event definednnn if (sortable.options && sortable[eventName]) {n sortable[eventName](_objectSpread({n sortable: sortablen }, evt));n }n });n },n initializePlugins: function initializePlugins(sortable, el, defaults, options) {n plugins.forEach(function (plugin) {n var pluginName = plugin.pluginName;n if (!sortable.options && !plugin.initializeByDefault) return;n var initialized = new plugin(sortable, el, sortable.options);n initialized.sortable = sortable;n initialized.options = sortable.options;n sortable = initialized; // Add default options from pluginnn _extends(defaults, initialized.defaults);n });nn for (var option in sortable.options) {n if (!sortable.options.hasOwnProperty(option)) continue;n var modified = this.modifyOption(sortable, option, sortable.options);nn if (typeof modified !== 'undefined') {n sortable.options = modified;n }n }n },n getEventProperties: function getEventProperties(name, sortable) {n var eventProperties = {};n plugins.forEach(function (plugin) {n if (typeof plugin.eventProperties !== 'function') return;nn _extends(eventProperties, plugin.eventProperties.call(sortable, name));n });n return eventProperties;n },n modifyOption: function modifyOption(sortable, name, value) {n var modifiedValue;n plugins.forEach(function (plugin) {n // Plugin must exist on the Sortablen if (!sortable) return; // If static option listener exists for this option, call in the context of the Sortable's instance of this pluginnn if (plugin.optionListeners && typeof plugin.optionListeners === 'function') {n modifiedValue = plugin.optionListeners.call(sortable, value);n }n });n return modifiedValue;n }n};nnfunction dispatchEvent(_ref) {n var sortable = _ref.sortable,n rootEl = _ref.rootEl,n name = _ref.name,n targetEl = _ref.targetEl,n cloneEl = _ref.cloneEl,n toEl = _ref.toEl,n fromEl = _ref.fromEl,n oldIndex = _ref.oldIndex,n newIndex = _ref.newIndex,n oldDraggableIndex = _ref.oldDraggableIndex,n newDraggableIndex = _ref.newDraggableIndex,n originalEvent = _ref.originalEvent,n putSortable = _ref.putSortable,n extraEventProperties = _ref.extraEventProperties;n sortable = sortable || rootEl && rootEl;n if (!sortable) return;n var evt,n options = sortable.options,n onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1); // Support for new CustomEvent featurenn if (window.CustomEvent && !IE11OrLess && !Edge) {n evt = new CustomEvent(name, {n bubbles: true,n cancelable: truen });n } else {n evt = document.createEvent('Event');n evt.initEvent(name, true, true);n }nn evt.to = toEl || rootEl;n evt.from = fromEl || rootEl;n evt.item = targetEl || rootEl;n evt.clone = cloneEl;n evt.oldIndex = oldIndex;n evt.newIndex = newIndex;n evt.oldDraggableIndex = oldDraggableIndex;n evt.newDraggableIndex = newDraggableIndex;n evt.originalEvent = originalEvent;n evt.pullMode = putSortable ? putSortable.lastPutMode : undefined;nn var allEventProperties = _objectSpread({}, extraEventProperties, PluginManager.getEventProperties(name, sortable));nn for (var option in allEventProperties) {n evt = allEventProperties;n }nn if (rootEl) {n rootEl.dispatchEvent(evt);n }nn if (options) {n options.call(sortable, evt);n }n}nnvar pluginEvent = function pluginEvent(eventName, sortable) {n var _ref = arguments.length > 2 && arguments !== undefined ? arguments : {},n originalEvent = _ref.evt,n data = _objectWithoutProperties(_ref, ["evt"]);nn PluginManager.pluginEvent.bind(Sortable)(eventName, sortable, _objectSpread({n dragEl: dragEl,n parentEl: parentEl,n ghostEl: ghostEl,n rootEl: rootEl,n nextEl: nextEl,n lastDownEl: lastDownEl,n cloneEl: cloneEl,n cloneHidden: cloneHidden,n dragStarted: moved,n putSortable: putSortable,n activeSortable: Sortable.active,n originalEvent: originalEvent,n oldIndex: oldIndex,n oldDraggableIndex: oldDraggableIndex,n newIndex: newIndex,n newDraggableIndex: newDraggableIndex,n hideGhostForTarget: _hideGhostForTarget,n unhideGhostForTarget: _unhideGhostForTarget,n cloneNowHidden: function cloneNowHidden() {n cloneHidden = true;n },n cloneNowShown: function cloneNowShown() {n cloneHidden = false;n },n dispatchSortableEvent: function dispatchSortableEvent(name) {n _dispatchEvent({n sortable: sortable,n name: name,n originalEvent: originalEventn });n }n }, data));n};nnfunction _dispatchEvent(info) {n dispatchEvent(_objectSpread({n putSortable: putSortable,n cloneEl: cloneEl,n targetEl: dragEl,n rootEl: rootEl,n oldIndex: oldIndex,n oldDraggableIndex: oldDraggableIndex,n newIndex: newIndex,n newDraggableIndex: newDraggableIndexn }, info));n}nnif (typeof window === "undefined" || !window.document) {n throw new Error("Sortable.js requires a window with a document");n}nnvar dragEl,n parentEl,n ghostEl,n rootEl,n nextEl,n lastDownEl,n cloneEl,n cloneHidden,n oldIndex,n newIndex,n oldDraggableIndex,n newDraggableIndex,n activeGroup,n putSortable,n awaitingDragStarted = false,n ignoreNextClick = false,n sortables = [],n tapEvt,n touchEvt,n lastDx,n lastDy,n tapDistanceLeft,n tapDistanceTop,n moved,n lastTarget,n lastDirection,n pastFirstInvertThresh = false,n isCircumstantialInvert = false,n targetMoveDistance,n // For positioning ghost absolutelynghostRelativeParent,n ghostRelativeParentInitialScroll = [],n // (left, top)n_silent = false,n savedInputChecked = [];n/** @const */nnvar PositionGhostAbsolutely = IOS,n CSSFloatProperty = Edge || IE11OrLess ? 'cssFloat' : 'float',n // This will not pass for IE9, because IE9 DnD only works on anchorsnsupportDraggable = !ChromeForAndroid && !IOS && 'draggable' in document.createElement('div'),n supportCssPointerEvents = function () {n // false when <= IE11n if (IE11OrLess) {n return false;n }nn var el = document.createElement('x');n el.style.cssText = 'pointer-events:auto';n return el.style.pointerEvents === 'auto';n}(),n _detectDirection = function _detectDirection(el, options) {n var elCSS = css(el),n elWidth = parseInt(elCSS.width) - parseInt(elCSS.paddingLeft) - parseInt(elCSS.paddingRight) - parseInt(elCSS.borderLeftWidth) - parseInt(elCSS.borderRightWidth),n child1 = getChild(el, 0, options),n child2 = getChild(el, 1, options),n firstChildCSS = child1 && css(child1),n secondChildCSS = child2 && css(child2),n firstChildWidth = firstChildCSS && parseInt(firstChildCSS.marginLeft) + parseInt(firstChildCSS.marginRight) + getRect(child1).width,n secondChildWidth = secondChildCSS && parseInt(secondChildCSS.marginLeft) + parseInt(secondChildCSS.marginRight) + getRect(child2).width;nn if (elCSS.display === 'flex') {n return elCSS.flexDirection === 'column' || elCSS.flexDirection === 'column-reverse' ? 'vertical' : 'horizontal';n }nn if (elCSS.display === 'grid') {n return elCSS.gridTemplateColumns.split(' ').length <= 1 ? 'vertical' : 'horizontal';n }nn if (child1 && firstChildCSS && firstChildCSS !== 'none') {n var touchingSideChild2 = firstChildCSS === 'left' ? 'left' : 'right';n return child2 && (secondChildCSS.clear === 'both' || secondChildCSS.clear === touchingSideChild2) ? 'vertical' : 'horizontal';n }nn return child1 && (firstChildCSS.display === 'block' || firstChildCSS.display === 'flex' || firstChildCSS.display === 'table' || firstChildCSS.display === 'grid' || firstChildWidth >= elWidth && elCSS === 'none' || child2 && elCSS === 'none' && firstChildWidth + secondChildWidth > elWidth) ? 'vertical' : 'horizontal';n},n _dragElInRowColumn = function _dragElInRowColumn(dragRect, targetRect, vertical) {n var dragElS1Opp = vertical ? dragRect.left : dragRect.top,n dragElS2Opp = vertical ? dragRect.right : dragRect.bottom,n dragElOppLength = vertical ? dragRect.width : dragRect.height,n targetS1Opp = vertical ? targetRect.left : targetRect.top,n targetS2Opp = vertical ? targetRect.right : targetRect.bottom,n targetOppLength = vertical ? targetRect.width : targetRect.height;n return dragElS1Opp === targetS1Opp || dragElS2Opp === targetS2Opp || dragElS1Opp + dragElOppLength / 2 === targetS1Opp + targetOppLength / 2;n},nn/**rn * Detects first nearest empty sortable to X and Y position using emptyInsertThreshold.rn * @param {Number} x X positionrn * @param {Number} y Y positionrn * @return {HTMLElement} Element of the first found nearest Sortablern */n_detectNearestEmptySortable = function _detectNearestEmptySortable(x, y) {n var ret;n sortables.some(function (sortable) {n if (lastChild(sortable)) return;n var rect = getRect(sortable),n threshold = sortable.options.emptyInsertThreshold,n insideHorizontally = x >= rect.left - threshold && x <= rect.right + threshold,n insideVertically = y >= rect.top - threshold && y <= rect.bottom + threshold;nn if (threshold && insideHorizontally && insideVertically) {n return ret = sortable;n }n });n return ret;n},n _prepareGroup = function _prepareGroup(options) {n function toFn(value, pull) {n return function (to, from, dragEl, evt) {n var sameGroup = to.options.group.name && from.options.group.name && to.options.group.name === from.options.group.name;nn if (value == null && (pull || sameGroup)) {n // Default pull valuen // Default pull and put value if same groupn return true;n } else if (value == null || value === false) {n return false;n } else if (pull && value === 'clone') {n return value;n } else if (typeof value === 'function') {n return toFn(value(to, from, dragEl, evt), pull)(to, from, dragEl, evt);n } else {n var otherGroup = (pull ? to : from).options.group.name;n return value === true || typeof value === 'string' && value === otherGroup || value.join && value.indexOf(otherGroup) > -1;n }n };n }nn var group = {};n var originalGroup = options.group;nn if (!originalGroup || _typeof(originalGroup) != 'object') {n originalGroup = {n name: originalGroupn };n }nn group.name = originalGroup.name;n group.checkPull = toFn(originalGroup.pull, true);n group.checkPut = toFn(originalGroup.put);n group.revertClone = originalGroup.revertClone;n options.group = group;n},n _hideGhostForTarget = function _hideGhostForTarget() {n if (!supportCssPointerEvents && ghostEl) {n css(ghostEl, 'display', 'none');n }n},n _unhideGhostForTarget = function _unhideGhostForTarget() {n if (!supportCssPointerEvents && ghostEl) {n css(ghostEl, 'display', '');n }n}; // #1184 fix - Prevent click event on fallback if dragged but item not changed positionnnndocument.addEventListener('click', function (evt) {n if (ignoreNextClick) {n evt.preventDefault();n evt.stopPropagation && evt.stopPropagation();n evt.stopImmediatePropagation && evt.stopImmediatePropagation();n ignoreNextClick = false;n return false;n }n}, true);nnvar nearestEmptyInsertDetectEvent = function nearestEmptyInsertDetectEvent(evt) {n if (dragEl) {n evt = evt.touches ? evt.touches : evt;nn var nearest = _detectNearestEmptySortable(evt.clientX, evt.clientY);nn if (nearest) {n // Create imitation eventn var event = {};nn for (var i in evt) {n if (evt.hasOwnProperty(i)) {n event = evt;n }n }nn event.target = event.rootEl = nearest;n event.preventDefault = void 0;n event.stopPropagation = void 0;nn nearest._onDragOver(event);n }n }n};nnvar _checkOutsideTargetEl = function _checkOutsideTargetEl(evt) {n if (dragEl) {n dragEl.parentNode._isOutsideThisEl(evt.target);n }n};n/**rn * @class Sortablern * @param {HTMLElement} elrn * @param {Object} [options]rn */nnnfunction Sortable(el, options) {n if (!(el && el.nodeType && el.nodeType === 1)) {n throw "Sortable: `el` must be an HTMLElement, not ".concat({}.toString.call(el));n }nn this.el = el; // root elementnn this.options = options = _extends({}, options); // Export instancenn el = this;n var defaults = {n group: null,n sort: true,n disabled: false,n store: null,n handle: null,n draggable: /^[uo]l$/i.test(el.nodeName) ? '>li' : '>*',n swapThreshold: 1,n // percentage; 0 <= x <= 1n invertSwap: false,n // invert alwaysn invertedSwapThreshold: null,n // will be set to same as swapThreshold if defaultn removeCloneOnHide: true,n direction: function direction() {n return _detectDirection(el, this.options);n },n ghostClass: 'sortable-ghost',n chosenClass: 'sortable-chosen',n dragClass: 'sortable-drag',n ignore: 'a, img',n filter: null,n preventOnFilter: true,n animation: 0,n easing: null,n setData: function setData(dataTransfer, dragEl) {n dataTransfer.setData('Text', dragEl.textContent);n },n dropBubble: false,n dragoverBubble: false,n dataIdAttr: 'data-id',n delay: 0,n delayOnTouchOnly: false,n touchStartThreshold: (Number.parseInt ? Number
: window).parseInt(window.devicePixelRatio, 10) || 1,n forceFallback: false,n fallbackClass: 'sortable-fallback',n fallbackOnBody: false,n fallbackTolerance: 0,n fallbackOffset: {n x: 0,n y: 0n },n supportPointer: Sortable.supportPointer !== false && 'PointerEvent' in window,n emptyInsertThreshold: 5n };n PluginManager.initializePlugins(this, el, defaults); // Set default optionsnn for (var name in defaults) {n !(name in options) && (options = defaults);n }nn _prepareGroup(options); // Bind all private methodsnnn for (var fn in this) {n if (fn.charAt(0) === '_' && typeof this === 'function') {n this = this.bind(this);n }n } // Setup drag modennn this.nativeDraggable = options.forceFallback ? false : supportDraggable;nn if (this.nativeDraggable) {n // Touch start threshold cannot be greater than the native dragstart thresholdn this.options.touchStartThreshold = 1;n } // Bind eventsnnn if (options.supportPointer) {n on(el, 'pointerdown', this._onTapStart);n } else {n on(el, 'mousedown', this._onTapStart);n on(el, 'touchstart', this._onTapStart);n }nn if (this.nativeDraggable) {n on(el, 'dragover', this);n on(el, 'dragenter', this);n }nn sortables.push(this.el); // Restore sortingnn options.store && options.store.get && this.sort(options.store.get(this) || []); // Add animation state managernn _extends(this, AnimationStateManager());n}nnSortable.prototype =n/** @lends Sortable.prototype */n{n constructor: Sortable,n _isOutsideThisEl: function _isOutsideThisEl(target) {n if (!this.el.contains(target) && target !== this.el) {n lastTarget = null;n }n },n _getDirection: function _getDirection(evt, target) {n return typeof this.options.direction === 'function' ? this.options.direction.call(this, evt, target, dragEl) : this.options.direction;n },n _onTapStart: function _onTapStart(n /** Event|TouchEvent */n evt) {n if (!evt.cancelable) return;nn var _this = this,n el = this.el,n options = this.options,n preventOnFilter = options.preventOnFilter,n type = evt.type,n touch = evt.touches && evt.touches || evt.pointerType && evt.pointerType === 'touch' && evt,n target = (touch || evt).target,n originalTarget = evt.target.shadowRoot && (evt.path && evt.path || evt.composedPath && evt.composedPath()) || target,n filter = options.filter;nn _saveInputCheckedState(el); // Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.nnn if (dragEl) {n return;n }nn if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {n return; // only left button and enabledn } // cancel dnd if original target is content editablennn if (originalTarget.isContentEditable) {n return;n }nn target = closest(target, options.draggable, el, false);nn if (target && target.animated) {n return;n }nn if (lastDownEl === target) {n // Ignoring duplicate `down`n return;n } // Get the index of the dragged element within its parentnnn oldIndex = index(target);n oldDraggableIndex = index(target, options.draggable); // Check filternn if (typeof filter === 'function') {n if (filter.call(this, evt, target, this)) {n _dispatchEvent({n sortable: _this,n rootEl: originalTarget,n name: 'filter',n targetEl: target,n toEl: el,n fromEl: eln });nn pluginEvent('filter', _this, {n evt: evtn });n preventOnFilter && evt.cancelable && evt.preventDefault();n return; // cancel dndn }n } else if (filter) {n filter = filter.split(',').some(function (criteria) {n criteria = closest(originalTarget, criteria.trim(), el, false);nn if (criteria) {n _dispatchEvent({n sortable: _this,n rootEl: criteria,n name: 'filter',n targetEl: target,n fromEl: el,n toEl: eln });nn pluginEvent('filter', _this, {n evt: evtn });n return true;n }n });nn if (filter) {n preventOnFilter && evt.cancelable && evt.preventDefault();n return; // cancel dndn }n }nn if (options.handle && !closest(originalTarget, options.handle, el, false)) {n return;n } // Prepare `dragstart`nnn this._prepareDragStart(evt, touch, target);n },n _prepareDragStart: function _prepareDragStart(n /** Event */n evt,n /** Touch */n touch,n /** HTMLElement */n target) {n var _this = this,n el = _this.el,n options = _this.options,n ownerDocument = el.ownerDocument,n dragStartFn;nn if (target && !dragEl && target.parentNode === el) {n var dragRect = getRect(target);n rootEl = el;n dragEl = target;n parentEl = dragEl.parentNode;n nextEl = dragEl.nextSibling;n lastDownEl = target;n activeGroup = options.group;n Sortable.dragged = dragEl;n tapEvt = {n target: dragEl,n clientX: (touch || evt).clientX,n clientY: (touch || evt).clientYn };n tapDistanceLeft = tapEvt.clientX - dragRect.left;n tapDistanceTop = tapEvt.clientY - dragRect.top;n this._lastX = (touch || evt).clientX;n this._lastY = (touch || evt).clientY;n dragEl.style = 'all';nn dragStartFn = function dragStartFn() {n pluginEvent('delayEnded', _this, {n evt: evtn });nn if (Sortable.eventCanceled) {n _this._onDrop();nn return;n } // Delayed drag has been triggeredn // we can re-enable the events: touchmove/mousemovennn _this._disableDelayedDragEvents();nn if (!FireFox && _this.nativeDraggable) {n dragEl.draggable = true;n } // Bind the events: dragstart/dragendnnn _this._triggerDragStart(evt, touch); // Drag start eventnnn _dispatchEvent({n sortable: _this,n name: 'choose',n originalEvent: evtn }); // Chosen itemnnn toggleClass(dragEl, options.chosenClass, true);n }; // Disable "draggable"nnn options.ignore.split(',').forEach(function (criteria) {n find(dragEl, criteria.trim(), _disableDraggable);n });n on(ownerDocument, 'dragover', nearestEmptyInsertDetectEvent);n on(ownerDocument, 'mousemove', nearestEmptyInsertDetectEvent);n on(ownerDocument, 'touchmove', nearestEmptyInsertDetectEvent);n on(ownerDocument, 'mouseup', _this._onDrop);n on(ownerDocument, 'touchend', _this._onDrop);n on(ownerDocument, 'touchcancel', _this._onDrop); // Make
dragEl draggable (must be before delay for FireFox)nn if (FireFox && this.nativeDraggable) {n this.options.touchStartThreshold = 4;n dragEl.draggable = true;n }nn pluginEvent('delayStart', this, {n evt: evtn }); // Delay is impossible for native DnD in Edge or IEnn if (options.delay && (!options.delayOnTouchOnly || touch) && (!this.nativeDraggable || !(Edge || IE11OrLess))) {n if (Sortable.eventCanceled) {n this._onDrop();nn return;n } // If the user moves the pointer or let go the click or touchn // before the delay has been reached:n // disable the delayed dragnnn on(ownerDocument, 'mouseup', _this._disableDelayedDrag);n on(ownerDocument, 'touchend', _this._disableDelayedDrag);n on(ownerDocument, 'touchcancel', _this._disableDelayedDrag);n on(ownerDocument, 'mousemove', _this._delayedDragTouchMoveHandler);n on(ownerDocument, 'touchmove', _this._delayedDragTouchMoveHandler);n options.supportPointer && on(ownerDocument, 'pointermove', _this._delayedDragTouchMoveHandler);n _this._dragStartTimer = setTimeout(dragStartFn, options.delay);n } else {n dragStartFn();n }n }n },n _delayedDragTouchMoveHandler: function _delayedDragTouchMoveHandler(n /** TouchEvent|PointerEvent **/n e) {n var touch = e.touches ? e.touches : e;nn if (Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) >= Math.floor(this.options.touchStartThreshold / (this.nativeDraggable && window.devicePixelRatio || 1))) {n this._disableDelayedDrag();n }n },n _disableDelayedDrag: function _disableDelayedDrag() {n dragEl && _disableDraggable(dragEl);n clearTimeout(this._dragStartTimer);nn this._disableDelayedDragEvents();n },n _disableDelayedDragEvents: function _disableDelayedDragEvents() {n var ownerDocument = this.el.ownerDocument;n off(ownerDocument, 'mouseup', this._disableDelayedDrag);n off(ownerDocument, 'touchend', this._disableDelayedDrag);n off(ownerDocument, 'touchcancel', this._disableDelayedDrag);n off(ownerDocument, 'mousemove', this._delayedDragTouchMoveHandler);n off(ownerDocument, 'touchmove', this._delayedDragTouchMoveHandler);n off(ownerDocument, 'pointermove', this._delayedDragTouchMoveHandler);n },n _triggerDragStart: function _triggerDragStart(n /** Event */n evt,n /** Touch */n touch) {n touch = touch || evt.pointerType == 'touch' && evt;nn if (!this.nativeDraggable || touch) {n if (this.options.supportPointer) {n on(document, 'pointermove', this._onTouchMove);n } else if (touch) {n on(document, 'touchmove', this._onTouchMove);n } else {n on(document, 'mousemove', this._onTouchMove);n }n } else {n on(dragEl, 'dragend', this);n on(rootEl, 'dragstart', this._onDragStart);n }nn try {n if (document.selection) {n // Timeout neccessary for IE9n _nextTick(function () {n document.selection.empty();n });n } else {n window.getSelection().removeAllRanges();n }n } catch (err) {}n },n _dragStarted: function _dragStarted(fallback, evt) {n awaitingDragStarted = false;nn if (rootEl && dragEl) {n pluginEvent('dragStarted', this, {n evt: evtn });nn if (this.nativeDraggable) {n on(document, 'dragover', _checkOutsideTargetEl);n }nn var options = this.options; // Apply effectnn !fallback && toggleClass(dragEl, options.dragClass, false);n toggleClass(dragEl, options.ghostClass, true);n Sortable.active = this;n fallback && this._appendGhost(); // Drag start eventnn _dispatchEvent({n sortable: this,n name: 'start',n originalEvent: evtn });n } else {n this._nulling();n }n },n _emulateDragOver: function _emulateDragOver() {n if (touchEvt) {n this._lastX = touchEvt.clientX;n this._lastY = touchEvt.clientY;nn _hideGhostForTarget();nn var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);n var parent = target;nn while (target && target.shadowRoot) {n target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);n if (target === parent) break;n parent = target;n }nn dragEl.parentNode._isOutsideThisEl(target);nn if (parent) {n do {n if (parent) {n var inserted = void 0;n inserted = parent._onDragOver({n clientX: touchEvt.clientX,n clientY: touchEvt.clientY,n target: target,n rootEl: parentn });nn if (inserted && !this.options.dragoverBubble) {n break;n }n }nn target = parent; // store last elementn }n /* jshint boss:true */n while (parent = parent.parentNode);n }nn _unhideGhostForTarget();n }n },n _onTouchMove: function _onTouchMove(n /*TouchEvent/n evt) {n if (tapEvt) {n var options = this.options,n fallbackTolerance = options.fallbackTolerance,n fallbackOffset = options.fallbackOffset,n touch = evt.touches ? evt.touches : evt,n ghostMatrix = ghostEl && matrix(ghostEl),n scaleX = ghostEl && ghostMatrix && ghostMatrix.a,n scaleY = ghostEl && ghostMatrix && ghostMatrix.d,n relativeScrollOffset = PositionGhostAbsolutely && ghostRelativeParent && getRelativeScrollOffset(ghostRelativeParent),n dx = (touch.clientX - tapEvt.clientX + fallbackOffset.x) / (scaleX || 1) + (relativeScrollOffset ? relativeScrollOffset - ghostRelativeParentInitialScroll : 0) / (scaleX || 1),n dy = (touch.clientY - tapEvt.clientY + fallbackOffset.y) / (scaleY || 1) + (relativeScrollOffset ? relativeScrollOffset - ghostRelativeParentInitialScroll : 0) / (scaleY || 1); // only set the status to dragging, when we are actually draggingnn if (!Sortable.active && !awaitingDragStarted) {n if (fallbackTolerance && Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) < fallbackTolerance) {n return;n }nn this._onDragStart(evt, true);n }nn if (ghostEl) {n if (ghostMatrix) {n ghostMatrix.e += dx - (lastDx || 0);n ghostMatrix.f += dy - (lastDy || 0);n } else {n ghostMatrix = {n a: 1,n b: 0,n c: 0,n d: 1,n e: dx,n f: dyn };n }nn var cssMatrix = "matrix(".concat(ghostMatrix.a, ",").concat(ghostMatrix.b, ",").concat(ghostMatrix.c, ",").concat(ghostMatrix.d, ",").concat(ghostMatrix.e, ",").concat(ghostMatrix.f, ")");n css(ghostEl, 'webkitTransform', cssMatrix);n css(ghostEl, 'mozTransform', cssMatrix);n css(ghostEl, 'msTransform', cssMatrix);n css(ghostEl, 'transform', cssMatrix);n lastDx = dx;n lastDy = dy;n touchEvt = touch;n }nn evt.cancelable && evt.preventDefault();n }n },n _appendGhost: function _appendGhost() {n // Bug if using scale(): stackoverflow.com/questions/2637058n // Not being adjusted forn if (!ghostEl) {n var container = this.options.fallbackOnBody ? document.body : rootEl,n rect = getRect(dragEl, true, PositionGhostAbsolutely, true, container),n options = this.options; // Position absolutelynn if (PositionGhostAbsolutely) {n // Get relatively positioned parentn ghostRelativeParent = container;nn while (css(ghostRelativeParent, 'position') === 'static' && css(ghostRelativeParent, 'transform') === 'none' && ghostRelativeParent !== document) {n ghostRelativeParent = ghostRelativeParent.parentNode;n }nn if (ghostRelativeParent !== document.body && ghostRelativeParent !== document.documentElement) {n if (ghostRelativeParent === document) ghostRelativeParent = getWindowScrollingElement();n rect.top += ghostRelativeParent.scrollTop;n rect.left += ghostRelativeParent.scrollLeft;n } else {n ghostRelativeParent = getWindowScrollingElement();n }nn ghostRelativeParentInitialScroll = getRelativeScrollOffset(ghostRelativeParent);n }nn ghostEl = dragEl.cloneNode(true);n toggleClass(ghostEl, options.ghostClass, false);n toggleClass(ghostEl, options.fallbackClass, true);n toggleClass(ghostEl, options.dragClass, true);n css(ghostEl, 'transition', '');n css(ghostEl, 'transform', '');n css(ghostEl, 'box-sizing', 'border-box');n css(ghostEl, 'margin', 0);n css(ghostEl, 'top', rect.top);n css(ghostEl, 'left', rect.left);n css(ghostEl, 'width', rect.width);n css(ghostEl, 'height', rect.height);n css(ghostEl, 'opacity', '0.8');n css(ghostEl, 'position', PositionGhostAbsolutely ? 'absolute' : 'fixed');n css(ghostEl, 'zIndex', '100000');n css(ghostEl, 'pointerEvents', 'none');n Sortable.ghost = ghostEl;n container.appendChild(ghostEl); // Set transform-originnn css(ghostEl, 'transform-origin', tapDistanceLeft / parseInt(ghostEl.style.width) * 100 + '% ' + tapDistanceTop / parseInt(ghostEl.style.height) * 100 + '%');n }n },n _onDragStart: function _onDragStart(n /*Event/n evt,n /*boolean/n fallback) {n var _this = this;nn var dataTransfer = evt.dataTransfer;n var options = _this.options;n pluginEvent('dragStart', this, {n evt: evtn });nn if (Sortable.eventCanceled) {n this._onDrop();nn return;n }nn pluginEvent('setupClone', this);nn if (!Sortable.eventCanceled) {n cloneEl = clone(dragEl);n cloneEl.draggable = false;n cloneEl.style = '';nn this._hideClone();nn toggleClass(cloneEl, this.options.chosenClass, false);n Sortable.clone = cloneEl;n } // #1143: IFrame support workaroundnnn _this.cloneId = _nextTick(function () {n pluginEvent('clone', _this);n if (Sortable.eventCanceled) return;nn if (!_this.options.removeCloneOnHide) {n rootEl.insertBefore(cloneEl, dragEl);n }nn _this._hideClone();nn _dispatchEvent({n sortable: _this,n name: 'clone'n });n });n !fallback && toggleClass(dragEl, options.dragClass, true); // Set proper drop eventsnn if (fallback) {n ignoreNextClick = true;n _this._loopId = setInterval(_this._emulateDragOver, 50);n } else {n // Undo what was set in _prepareDragStart before drag startedn off(document, 'mouseup', _this._onDrop);n off(document, 'touchend', _this._onDrop);n off(document, 'touchcancel', _this._onDrop);nn if (dataTransfer) {n dataTransfer.effectAllowed = 'move';n options.setData && options.setData.call(_this, dataTransfer, dragEl);n }nn on(document, 'drop', _this); // #1276 fix:nn css(dragEl, 'transform', 'translateZ(0)');n }nn awaitingDragStarted = true;n _this._dragStartId = _nextTick(_this._dragStarted.bind(_this, fallback, evt));n on(document, 'selectstart', _this);n moved = true;nn if (Safari) {n css(document.body, 'user-select', 'none');n }n },n // Returns true - if no further action is needed (either inserted or another condition)n _onDragOver: function _onDragOver(n /*Event/n evt) {n var el = this.el,n target = evt.target,n dragRect,n targetRect,n revert,n options = this.options,n group = options.group,n activeSortable = Sortable.active,n isOwner = activeGroup === group,n canSort = options.sort,n fromSortable = putSortable || activeSortable,n vertical,n _this = this,n completedFired = false;nn if (_silent) return;nn function dragOverEvent(name, extra) {n pluginEvent(name, _this, _objectSpread({n evt: evt,n isOwner: isOwner,n axis: vertical ? 'vertical' : 'horizontal',n revert: revert,n dragRect: dragRect,n targetRect: targetRect,n canSort: canSort,n fromSortable: fromSortable,n target: target,n completed: completed,n onMove: function onMove(target, after) {n return _onMove(rootEl, el, dragEl, dragRect, target, getRect(target), evt, after);n },n changed: changedn }, extra));n } // Capture animation statennn function capture() {n dragOverEvent('dragOverAnimationCapture');nn _this.captureAnimationState();nn if (_this !== fromSortable) {n fromSortable.captureAnimationState();n }n } // Return invocation when dragEl is inserted (or completed)nnn function completed(insertion) {n dragOverEvent('dragOverCompleted', {n insertion: insertionn });nn if (insertion) {n // Clones must be hidden before folding animation to capture dragRectAbsolute properlyn if (isOwner) {n activeSortable._hideClone();n } else {n activeSortable._showClone(_this);n }nn if (_this !== fromSortable) {n // Set ghost class to new sortable's ghost classn toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : activeSortable.options.ghostClass, false);n toggleClass(dragEl, options.ghostClass, true);n }nn if (putSortable !== _this && _this !== Sortable.active) {n putSortable = _this;n } else if (_this === Sortable.active && putSortable) {n putSortable = null;n } // Animationnnn if (fromSortable === _this) {n _this._ignoreWhileAnimating = target;n }nn _this.animateAll(function () {n dragOverEvent('dragOverAnimationComplete');n _this._ignoreWhileAnimating = null;n });nn if (_this !== fromSortable) {n fromSortable.animateAll();n fromSortable._ignoreWhileAnimating = null;n }n } // Null lastTarget if it is not inside a previously swapped elementnnn if (target === dragEl && !dragEl.animated || target === el && !target.animated) {n lastTarget = null;n } // no bubbling and not fallbacknnn if (!options.dragoverBubble && !evt.rootEl && target !== document) {n dragEl.parentNode._isOutsideThisEl(evt.target); // Do not detect for empty insert if already insertednnn !insertion && nearestEmptyInsertDetectEvent(evt);n }nn !options.dragoverBubble && evt.stopPropagation && evt.stopPropagation();n return completedFired = true;n } // Call when dragEl has been insertednnn function changed() {n newIndex = index(dragEl);n newDraggableIndex = index(dragEl, options.draggable);nn _dispatchEvent({n sortable: _this,n name: 'change',n toEl: el,n newIndex: newIndex,n newDraggableIndex: newDraggableIndex,n originalEvent: evtn });n }nn if (evt.preventDefault !== void 0) {n evt.cancelable && evt.preventDefault();n }nn target = closest(target, options.draggable, el, true);n dragOverEvent('dragOver');n if (Sortable.eventCanceled) return completedFired;nn if (dragEl.contains(evt.target) || target.animated && target.animatingX && target.animatingY || _this._ignoreWhileAnimating === target) {n return completed(false);n }nn ignoreNextClick = false;nn if (activeSortable && !options.disabled && (isOwner ? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original listn : putSortable === this || (this.lastPutMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) && group.checkPut(this, activeSortable, dragEl, evt))) {n vertical = this._getDirection(evt, target) === 'vertical';n dragRect = getRect(dragEl);n dragOverEvent('dragOverValid');n if (Sortable.eventCanceled) return completedFired;nn if (revert) {n parentEl = rootEl; // actualizationnn capture();nn this._hideClone();nn dragOverEvent('revert');nn if (!Sortable.eventCanceled) {n if (nextEl) {n rootEl.insertBefore(dragEl, nextEl);n } else {n rootEl.appendChild(dragEl);n }n }nn return completed(true);n }nn var elLastChild = lastChild(el, options.draggable);nn if (!elLastChild || _ghostIsLast(evt, vertical, this) && !elLastChild.animated) {n // If already at end of list: Do not insertn if (elLastChild === dragEl) {n return completed(false);n } // assign target only if condition is truennn if (elLastChild && el === evt.target) {n target = elLastChild;n }nn if (target) {n targetRect = getRect(target);n }nn if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, !!target) !== false) {n capture();n el.appendChild(dragEl);n parentEl = el; // actualizationnn changed();n return completed(true);n }n } else if (target.parentNode === el) {n targetRect = getRect(target);n var direction = 0,n targetBeforeFirstSwap,n differentLevel = dragEl.parentNode !== el,n differentRowCol = !_dragElInRowColumn(dragEl.animated && dragEl.toRect || dragRect, target.animated && target.toRect || targetRect, vertical),n side1 = vertical ? 'top' : 'left',n scrolledPastTop = isScrolledPast(target, 'top', 'top') || isScrolledPast(dragEl, 'top', 'top'),n scrollBefore = scrolledPastTop ? scrolledPastTop.scrollTop : void 0;nn if (lastTarget !== target) {n targetBeforeFirstSwap = targetRect;n pastFirstInvertThresh = false;n isCircumstantialInvert = !differentRowCol && options.invertSwap || differentLevel;n }nn direction = _getSwapDirection(evt, target, targetRect, vertical, differentRowCol ? 1 : options.swapThreshold, options.invertedSwapThreshold == null ? options.swapThreshold : options.invertedSwapThreshold, isCircumstantialInvert, lastTarget === target);n var sibling;nn if (direction !== 0) {n // Check if target is beside dragEl in respective direction (ignoring hidden elements)n var dragIndex = index(dragEl);nn do {n dragIndex -= direction;n sibling = parentEl.children;n } while (sibling && (css(sibling, 'display') === 'none' || sibling === ghostEl));n } // If dragEl is already beside target: Do not insertnnn if (direction === 0 || sibling === target) {n return completed(false);n }nn lastTarget = target;n lastDirection = direction;n var nextSibling = target.nextElementSibling,n after = false;n after = direction === 1;nn var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);nn if (moveVector !== false) {n if (moveVector === 1 || moveVector === -1) {n after = moveVector === 1;n }nn _silent = true;n setTimeout(_unsilent, 30);n capture();nn if (after && !nextSibling) {n el.appendChild(dragEl);n } else {n target.parentNode.insertBefore(dragEl, after ? nextSibling : target);n } // Undo chrome's scroll adjustment (has no effect on other browsers)nnn if (scrolledPastTop) {n scrollBy(scrolledPastTop, 0, scrollBefore - scrolledPastTop.scrollTop);n }nn parentEl = dragEl.parentNode; // actualizationn // must be done before animationnn if (targetBeforeFirstSwap !== undefined && !isCircumstantialInvert) {n targetMoveDistance = Math.abs(targetBeforeFirstSwap - getRect(target));n }nn changed();n return completed(true);n }n }nn if (el.contains(dragEl)) {n return completed(false);n }n }nn return false;n },n _ignoreWhileAnimating: null,n _offMoveEvents: function _offMoveEvents() {n off(document, 'mousemove', this._onTouchMove);n off(document, 'touchmove', this._onTouchMove);n off(document, 'pointermove', this._onTouchMove);n off(document, 'dragover', nearestEmptyInsertDetectEvent);n off(document, 'mousemove', nearestEmptyInsertDetectEvent);n off(document, 'touchmove', nearestEmptyInsertDetectEvent);n },n _offUpEvents: function _offUpEvents() {n var ownerDocument = this.el.ownerDocument;n off(ownerDocument, 'mouseup', this._onDrop);n off(ownerDocument, 'touchend', this._onDrop);n off(ownerDocument, 'pointerup', this._onDrop);n off(ownerDocument, 'touchcancel', this._onDrop);n off(document, 'selectstart', this);n },n _onDrop: function _onDrop(n /*Event/n evt) {n var el = this.el,n options = this.options; // Get the index of the dragged element within its parentnn newIndex = index(dragEl);n newDraggableIndex = index(dragEl, options.draggable);n pluginEvent('drop', this, {n evt: evtn });n parentEl = dragEl && dragEl.parentNode; // Get again after plugin eventnn newIndex = index(dragEl);n newDraggableIndex = index(dragEl, options.draggable);nn if (Sortable.eventCanceled) {n this._nulling();nn return;n }nn awaitingDragStarted = false;n isCircumstantialInvert = false;n pastFirstInvertThresh = false;n clearInterval(this._loopId);n clearTimeout(this._dragStartTimer);nn _cancelNextTick(this.cloneId);nn _cancelNextTick(this._dragStartId); // Unbind eventsnnn if (this.nativeDraggable) {n off(document, 'drop', this);n off(el, 'dragstart', this._onDragStart);n }nn this._offMoveEvents();nn this._offUpEvents();nn if (Safari) {n css(document.body, 'user-select', '');n }nn if (evt) {n if (moved) {n evt.cancelable && evt.preventDefault();n !options.dropBubble && evt.stopPropagation();n }nn ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);nn if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') {n // Remove clone(s)n cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);n }nn if (dragEl) {n if (this.nativeDraggable) {n off(dragEl, 'dragend', this);n }nn _disableDraggable(dragEl);nn dragEl.style = ''; // Remove classesn // ghostClass is added in dragStartednn if (moved && !awaitingDragStarted) {n toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : this.options.ghostClass, false);n }nn toggleClass(dragEl, this.options.chosenClass, false); // Drag stop eventnn _dispatchEvent({n sortable: this,n name: 'unchoose',n toEl: parentEl,n newIndex: null,n newDraggableIndex: null,n originalEvent: evtn });nn if (rootEl !== parentEl) {n if (newIndex >= 0) {n // Add eventn _dispatchEvent({n rootEl: parentEl,n name: 'add',n toEl: parentEl,n fromEl: rootEl,n originalEvent: evtn }); // Remove eventnnn _dispatchEvent({n sortable: this,n name: 'remove',n toEl: parentEl,n originalEvent: evtn }); // drag from one list and drop into anothernnn _dispatchEvent({n rootEl: parentEl,n name: 'sort',n toEl: parentEl,n fromEl: rootEl,n originalEvent: evtn });nn _dispatchEvent({n sortable: this,n name: 'sort',n toEl: parentEl,n originalEvent: evtn });n }nn putSortable && putSortable.save();n } else {n if (newIndex !== oldIndex) {n if (newIndex >= 0) {n // drag & drop within the same listn _dispatchEvent({n sortable: this,n name: 'update',n toEl: parentEl,n originalEvent: evtn });nn _dispatchEvent({n sortable: this,n name: 'sort',n toEl: parentEl,n originalEvent: evtn });n }n }n }nn if (Sortable.active) {n /* jshint eqnull:true */n if (newIndex == null || newIndex === -1) {n newIndex = oldIndex;n newDraggableIndex = oldDraggableIndex;n }nn _dispatchEvent({n sortable: this,n name: 'end',n toEl: parentEl,n originalEvent: evtn }); // Save sortingnnn this.save();n }n }n }nn this._nulling();n },n _nulling: function _nulling() {n pluginEvent('nulling', this);n rootEl = dragEl = parentEl = ghostEl = nextEl = cloneEl = lastDownEl = cloneHidden = tapEvt = touchEvt = moved = newIndex = newDraggableIndex = oldIndex = oldDraggableIndex = lastTarget = lastDirection = putSortable = activeGroup = Sortable.dragged = Sortable.ghost = Sortable.clone = Sortable.active = null;n savedInputChecked.forEach(function (el) {n el.checked = true;n });n savedInputChecked.length = lastDx = lastDy = 0;n },n handleEvent: function handleEvent(n /*Event/n evt) {n switch (evt.type) {n case 'drop':n case 'dragend':n this._onDrop(evt);nn break;nn case 'dragenter':n case 'dragover':n if (dragEl) {n this._onDragOver(evt);nn _globalDragOver(evt);n }nn break;nn case 'selectstart':n evt.preventDefault();n break;n }n },nn /**rn * Serializes the item into an array of string.rn * @returns {String[]}rn */n toArray: function toArray() {n var order = [],n el,n children = this.el.children,n i = 0,n n = children.length,n options = this.options;nn for (; i < n; i++) {n el = children;nn if (closest(el, options.draggable, this.el, false)) {n order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));n }n }nn return order;n },nn /**rn * Sorts the elements according to the array.rn * @param {String[]} order order of the itemsrn */n sort: function sort(order) {n var items = {},n rootEl = this.el;n this.toArray().forEach(function (id, i) {n var el = rootEl.children;nn if (closest(el, this.options.draggable, rootEl, false)) {n items = el;n }n }, this);n order.forEach(function (id) {n if (items) {n rootEl.removeChild(items);n rootEl.appendChild(items);n }n });n },nn /**rn * Save the current sortingrn */n save: function save() {n var store = this.options.store;n store && store.set && store.set(this);n },nn /**rn * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.rn * @param {HTMLElement} elrn * @param {String} [selector] default: `options.draggable`rn * @returns {HTMLElement|null}rn */n closest: function closest$1(el, selector) {n return closest(el, selector || this.options.draggable, this.el, false);n },nn /**rn * Set/get optionrn * @param {string} namern * @param {*} [value]rn * @returns {*}rn */n option: function option(name, value) {n var options = this.options;nn if (value === void 0) {n return options;n } else {n var modifiedValue = PluginManager.modifyOption(this, name, value);nn if (typeof modifiedValue !== 'undefined') {n options = modifiedValue;n } else {n options = value;n }nn if (name === 'group') {n _prepareGroup(options);n }n }n },nn /**rn * Destroyrn */n destroy: function destroy() {n pluginEvent('destroy', this);n var el = this.el;n el = null;n off(el, 'mousedown', this._onTapStart);n off(el, 'touchstart', this._onTapStart);n off(el, 'pointerdown', this._onTapStart);nn if (this.nativeDraggable) {n off(el, 'dragover', this);n off(el, 'dragenter', this);n } // Remove draggable attributesnnn Array.prototype.forEach.call(el.querySelectorAll(‘'), function (el) {n el.removeAttribute('draggable');n });nn this._onDrop();nn sortables.splice(sortables.indexOf(this.el), 1);n this.el = el = null;n },n _hideClone: function _hideClone() {n if (!cloneHidden) {n pluginEvent('hideClone', this);n if (Sortable.eventCanceled) return;n css(cloneEl, 'display', 'none');nn if (this.options.removeCloneOnHide && cloneEl.parentNode) {n cloneEl.parentNode.removeChild(cloneEl);n }nn cloneHidden = true;n }n },n _showClone: function _showClone(putSortable) {n if (putSortable.lastPutMode !== 'clone') {n this._hideClone();nn return;n }nn if (cloneHidden) {n pluginEvent('showClone', this);n if (Sortable.eventCanceled) return; // show clone at dragEl or original positionnn if (rootEl.contains(dragEl) && !this.options.group.revertClone) {n rootEl.insertBefore(cloneEl, dragEl);n } else if (nextEl) {n rootEl.insertBefore(cloneEl, nextEl);n } else {n rootEl.appendChild(cloneEl);n }nn if (this.options.group.revertClone) {n this.animate(dragEl, cloneEl);n }nn css(cloneEl, 'display', '');n cloneHidden = false;n }n }n};nnfunction _globalDragOver(n/*Event/nevt) {n if (evt.dataTransfer) {n evt.dataTransfer.dropEffect = 'move';n }nn evt.cancelable && evt.preventDefault();n}nnfunction _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvent, willInsertAfter) {n var evt,n sortable = fromEl,n onMoveFn = sortable.options.onMove,n retVal; // Support for new CustomEvent featurenn if (window.CustomEvent && !IE11OrLess && !Edge) {n evt = new CustomEvent('move', {n bubbles: true,n cancelable: truen });n } else {n evt = document.createEvent('Event');n evt.initEvent('move', true, true);n }nn evt.to = toEl;n evt.from = fromEl;n evt.dragged = dragEl;n evt.draggedRect = dragRect;n evt.related = targetEl || toEl;n evt.relatedRect = targetRect || getRect(toEl);n evt.willInsertAfter = willInsertAfter;n evt.originalEvent = originalEvent;n fromEl.dispatchEvent(evt);nn if (onMoveFn) {n retVal = onMoveFn.call(sortable, evt, originalEvent);n }nn return retVal;n}nnfunction _disableDraggable(el) {n el.draggable = false;n}nnfunction _unsilent() {n _silent = false;n}nnfunction _ghostIsLast(evt, vertical, sortable) {n var rect = getRect(lastChild(sortable.el, sortable.options.draggable));n var spacer = 10;n return vertical ? evt.clientX > rect.right + spacer || evt.clientX <= rect.right && evt.clientY > rect.bottom && evt.clientX >= rect.left : evt.clientX > rect.right && evt.clientY > rect.top || evt.clientX <= rect.right && evt.clientY > rect.bottom + spacer;n}nnfunction _getSwapDirection(evt, target, targetRect, vertical, swapThreshold, invertedSwapThreshold, invertSwap, isLastTarget) {n var mouseOnAxis = vertical ? evt.clientY : evt.clientX,n targetLength = vertical ? targetRect.height : targetRect.width,n targetS1 = vertical ? targetRect.top : targetRect.left,n targetS2 = vertical ? targetRect.bottom : targetRect.right,n invert = false;nn if (!invertSwap) {n // Never invert or create dragEl shadow when target movemenet causes mouse to move past the end of regular swapThresholdn if (isLastTarget && targetMoveDistance < targetLength * swapThreshold) {n // multiplied only by swapThreshold because mouse will already be inside target by (1 - threshold) * targetLength / 2n // check if past first invert threshold on side opposite of lastDirectionn if (!pastFirstInvertThresh && (lastDirection === 1 ? mouseOnAxis > targetS1 + targetLength * invertedSwapThreshold / 2 : mouseOnAxis < targetS2 - targetLength * invertedSwapThreshold / 2)) {n // past first invert threshold, do not restrict inverted threshold to dragEl shadown pastFirstInvertThresh = true;n }nn if (!pastFirstInvertThresh) {n // dragEl shadow (target move distance shadow)n if (lastDirection === 1 ? mouseOnAxis < targetS1 + targetMoveDistance // over dragEl shadown : mouseOnAxis > targetS2 - targetMoveDistance) {n return -lastDirection;n }n } else {n invert = true;n }n } else {n // Regularn if (mouseOnAxis > targetS1 + targetLength * (1 - swapThreshold) / 2 && mouseOnAxis < targetS2 - targetLength * (1 - swapThreshold) / 2) {n return _getInsertDirection(target);n }n }n }nn invert = invert || invertSwap;nn if (invert) {n // Invert of regularn if (mouseOnAxis < targetS1 + targetLength * invertedSwapThreshold / 2 || mouseOnAxis > targetS2 - targetLength * invertedSwapThreshold / 2) {n return mouseOnAxis > targetS1 + targetLength / 2 ? 1 : -1;n }n }nn return 0;n}n/**rn * Gets the direction dragEl must be swapped relative to target in order to make itrn * seem that dragEl has been "inserted" into that element's positionrn * @param {HTMLElement} target The target whose position dragEl is being inserted atrn * @return {Number} Direction dragEl must be swappedrn */nnnfunction _getInsertDirection(target) {n if (index(dragEl) < index(target)) {n return 1;n } else {n return -1;n }n}n/**rn * Generate idrn * @param {HTMLElement} elrn * @returns {String}rn * @privatern */nnnfunction _generateId(el) {n var str = el.tagName + el.className + el.src + el.href + el.textContent,n i = str.length,n sum = 0;nn while (i–) {n sum += str.charCodeAt(i);n }nn return sum.toString(36);n}nnfunction _saveInputCheckedState(root) {n savedInputChecked.length = 0;n var inputs = root.getElementsByTagName('input');n var idx = inputs.length;nn while (idx–) {n var el = inputs;n el.checked && savedInputChecked.push(el);n }n}nnfunction _nextTick(fn) {n return setTimeout(fn, 0);n}nnfunction _cancelNextTick(id) {n return clearTimeout(id);n} // Fixed #973:nnnon(document, 'touchmove', function (evt) {n if ((Sortable.active || awaitingDragStarted) && evt.cancelable) {n evt.preventDefault();n }n}); // Export utilsnnSortable.utils = {n on: on,n off: off,n css: css,n find: find,n is: function is(el, selector) {n return !!closest(el, selector, el, false);n },n extend: extend,n throttle: throttle,n closest: closest,n toggleClass: toggleClass,n clone: clone,n index: index,n nextTick: _nextTick,n cancelNextTick: _cancelNextTick,n detectDirection: _detectDirection,n getChild: getChildn};n/**rn * Get the Sortable instance of an elementrn * @param {HTMLElement} element The elementrn * @return {Sortable|undefined} The instance of Sortablern */nnSortable.get = function (element) {n return element;n};n/**rn * Mount a plugin to Sortablern * @param {…SortablePlugin|SortablePlugin[]} plugins Plugins being mountedrn */nnnSortable.mount = function () {n for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {n plugins = arguments;n }nn if (plugins.constructor === Array) plugins = plugins;n plugins.forEach(function (plugin) {n if (!plugin.prototype || !plugin.prototype.constructor) {n throw "Sortable: Mounted plugin must be a constructor function, not ".concat({}.toString.call(plugin));n }nn if (plugin.utils) Sortable.utils = _objectSpread({}, Sortable.utils, plugin.utils);n PluginManager.mount(plugin);n });n};n/**rn * Create sortable instancern * @param {HTMLElement} elrn * @param {Object} [options]rn */nnnSortable.create = function (el, options) {n return new Sortable(el, options);n}; // ExportnnnSortable.version = version;nvar autoScrolls = [],n scrollEl,n scrollRootEl,n scrolling = false,n lastAutoScrollX,n lastAutoScrollY,n touchEvt$1,n pointerElemChangedInterval;nnfunction AutoScrollPlugin() {n function AutoScroll() {n this.defaults = {n scroll: true,n scrollSensitivity: 30,n scrollSpeed: 10,n bubbleScroll: truen }; // Bind all private methodsnn for (var fn in this) {n if (fn.charAt(0) === '_' && typeof this === 'function') {n this = this.bind(this);n }n }n }nn AutoScroll.prototype = {n dragStarted: function dragStarted(_ref) {n var originalEvent = _ref.originalEvent;nn if (this.sortable.nativeDraggable) {n on(document, 'dragover', this._handleAutoScroll);n } else {n if (this.options.supportPointer) {n on(document, 'pointermove', this._handleFallbackAutoScroll);n } else if (originalEvent.touches) {n on(document, 'touchmove', this._handleFallbackAutoScroll);n } else {n on(document, 'mousemove', this._handleFallbackAutoScroll);n }n }n },n dragOverCompleted: function dragOverCompleted(_ref2) {n var originalEvent = _ref2.originalEvent; // For when bubbling is canceled and using fallback (fallback 'touchmove' always reached)nn if (!this.options.dragOverBubble && !originalEvent.rootEl) {n this._handleAutoScroll(originalEvent);n }n },n drop: function drop() {n if (this.sortable.nativeDraggable) {n off(document, 'dragover', this._handleAutoScroll);n } else {n off(document, 'pointermove', this._handleFallbackAutoScroll);n off(document, 'touchmove', this._handleFallbackAutoScroll);n off(document, 'mousemove', this._handleFallbackAutoScroll);n }nn clearPointerElemChangedInterval();n clearAutoScrolls();n cancelThrottle();n },n nulling: function nulling() {n touchEvt$1 = scrollRootEl = scrollEl = scrolling = pointerElemChangedInterval = lastAutoScrollX = lastAutoScrollY = null;n autoScrolls.length = 0;n },n _handleFallbackAutoScroll: function _handleFallbackAutoScroll(evt) {n this._handleAutoScroll(evt, true);n },n _handleAutoScroll: function _handleAutoScroll(evt, fallback) {n var _this = this;nn var x = (evt.touches ? evt.touches : evt).clientX,n y = (evt.touches ? evt.touches : evt).clientY,n elem = document.elementFromPoint(x, y);n touchEvt$1 = evt; // IE does not seem to have native autoscroll,n // Edge's autoscroll seems too conditional,n // MACOS Safari does not have autoscroll,n // Firefox and Chrome are goodnn if (fallback || Edge || IE11OrLess || Safari) {n autoScroll(evt, this.options, elem, fallback); // Listener for pointer element changenn var ogElemScroller = getParentAutoScrollElement(elem, true);nn if (scrolling && (!pointerElemChangedInterval || x !== lastAutoScrollX || y !== lastAutoScrollY)) {n pointerElemChangedInterval && clearPointerElemChangedInterval(); // Detect for pointer elem change, emulating native DnD behaviournn pointerElemChangedInterval = setInterval(function () {n var newElem = getParentAutoScrollElement(document.elementFromPoint(x, y), true);nn if (newElem !== ogElemScroller) {n ogElemScroller = newElem;n clearAutoScrolls();n }nn autoScroll(evt, _this.options, newElem, fallback);n }, 10);n lastAutoScrollX = x;n lastAutoScrollY = y;n }n } else {n // if DnD is enabled (and browser has good autoscrolling), first autoscroll will already scroll, so get parent autoscroll of first autoscrolln if (!this.options.bubbleScroll || getParentAutoScrollElement(elem, true) === getWindowScrollingElement()) {n clearAutoScrolls();n return;n }nn autoScroll(evt, this.options, getParentAutoScrollElement(elem, false), false);n }n }n };n return _extends(AutoScroll, {n pluginName: 'scroll',n initializeByDefault: truen });n}nnfunction clearAutoScrolls() {n autoScrolls.forEach(function (autoScroll) {n clearInterval(autoScroll.pid);n });n autoScrolls = [];n}nnfunction clearPointerElemChangedInterval() {n clearInterval(pointerElemChangedInterval);n}nnvar autoScroll = throttle(function (evt, options, rootEl, isFallback) {n // Bug: bugzilla.mozilla.org/show_bug.cgi?id=505521n if (!options.scroll) return;n var x = (evt.touches ? evt.touches : evt).clientX,n y = (evt.touches ? evt.touches : evt).clientY,n sens = options.scrollSensitivity,n speed = options.scrollSpeed,n winScroller = getWindowScrollingElement();n var scrollThisInstance = false,n scrollCustomFn; // New scroll root, set scrollElnn if (scrollRootEl !== rootEl) {n scrollRootEl = rootEl;n clearAutoScrolls();n scrollEl = options.scroll;n scrollCustomFn = options.scrollFn;nn if (scrollEl === true) {n scrollEl = getParentAutoScrollElement(rootEl, true);n }n }nn var layersOut = 0;n var currentParent = scrollEl;nn do {n var el = currentParent,n rect = getRect(el),n top = rect.top,n bottom = rect.bottom,n left = rect.left,n right = rect.right,n width = rect.width,n height = rect.height,n canScrollX = void 0,n canScrollY = void 0,n scrollWidth = el.scrollWidth,n scrollHeight = el.scrollHeight,n elCSS = css(el),n scrollPosX = el.scrollLeft,n scrollPosY = el.scrollTop;nn if (el === winScroller) {n canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll' || elCSS.overflowX === 'visible');n canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll' || elCSS.overflowY === 'visible');n } else {n canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll');n canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll');n }nn var vx = canScrollX && (Math.abs(right - x) <= sens && scrollPosX + width < scrollWidth) - (Math.abs(left - x) <= sens && !!scrollPosX);n var vy = canScrollY && (Math.abs(bottom - y) <= sens && scrollPosY + height < scrollHeight) - (Math.abs(top - y) <= sens && !!scrollPosY);nn if (!autoScrolls) {n for (var i = 0; i <= layersOut; i++) {n if (!autoScrolls) {n autoScrolls = {};n }n }n }nn if (autoScrolls.vx != vx || autoScrolls.vy != vy || autoScrolls.el !== el) {n autoScrolls.el = el;n autoScrolls.vx = vx;n autoScrolls.vy = vy;n clearInterval(autoScrolls.pid);nn if (vx != 0 || vy != 0) {n scrollThisInstance = true;n /* jshint loopfunc:true */nn autoScrolls.pid = setInterval(function () {n // emulate drag over during autoscroll (fallback), emulating native DnD behaviourn if (isFallback && this.layer === 0) {n Sortable.active._onTouchMove(touchEvt$1); // To move ghost if it is positioned absolutelynn }nn var scrollOffsetY = autoScrolls.vy ? autoScrolls.vy * speed : 0;n var scrollOffsetX = autoScrolls.vx ? autoScrolls.vx * speed : 0;nn if (typeof scrollCustomFn === 'function') {n if (scrollCustomFn.call(Sortable.dragged.parentNode, scrollOffsetX, scrollOffsetY, evt, touchEvt$1, autoScrolls.el) !== 'continue') {n return;n }n }nn scrollBy(autoScrolls.el, scrollOffsetX, scrollOffsetY);n }.bind({n layer: layersOutn }), 24);n }n }nn layersOut++;n } while (options.bubbleScroll && currentParent !== winScroller && (currentParent = getParentAutoScrollElement(currentParent, false)));nn scrolling = scrollThisInstance; // in case another function catches scrolling as false in between when it is notn}, 30);nnvar drop = function drop(_ref) {n var originalEvent = _ref.originalEvent,n putSortable = _ref.putSortable,n dragEl = _ref.dragEl,n activeSortable = _ref.activeSortable,n dispatchSortableEvent = _ref.dispatchSortableEvent,n hideGhostForTarget = _ref.hideGhostForTarget,n unhideGhostForTarget = _ref.unhideGhostForTarget;n var toSortable = putSortable || activeSortable;n hideGhostForTarget();n var touch = originalEvent.changedTouches && originalEvent.changedTouches.length ? originalEvent.changedTouches : originalEvent;n var target = document.elementFromPoint(touch.clientX, touch.clientY);n unhideGhostForTarget();nn if (toSortable && !toSortable.el.contains(target)) {n dispatchSortableEvent('spill');n this.onSpill({n dragEl: dragEl,n putSortable: putSortablen });n }n};nnfunction Revert() {}nnRevert.prototype = {n startIndex: null,n dragStart: function dragStart(_ref2) {n var oldDraggableIndex = _ref2.oldDraggableIndex;n this.startIndex = oldDraggableIndex;n },n onSpill: function onSpill(_ref3) {n var dragEl = _ref3.dragEl,n putSortable = _ref3.putSortable;n this.sortable.captureAnimationState();nn if (putSortable) {n putSortable.captureAnimationState();n }nn var nextSibling = getChild(this.sortable.el, this.startIndex, this.options);nn if (nextSibling) {n this.sortable.el.insertBefore(dragEl, nextSibling);n } else {n this.sortable.el.appendChild(dragEl);n }nn this.sortable.animateAll();nn if (putSortable) {n putSortable.animateAll();n }n },n drop: dropn};nn_extends(Revert, {n pluginName: 'revertOnSpill'n});nnfunction Remove() {}nnRemove.prototype = {n onSpill: function onSpill(_ref4) {n var dragEl = _ref4.dragEl,n putSortable = _ref4.putSortable;n var parentSortable = putSortable || this.sortable;n parentSortable.captureAnimationState();n dragEl.parentNode && dragEl.parentNode.removeChild(dragEl);n parentSortable.animateAll();n },n drop: dropn};nn_extends(Remove, {n pluginName: 'removeOnSpill'n});nnvar lastSwapEl;nnfunction SwapPlugin() {n function Swap() {n this.defaults = {n swapClass: 'sortable-swap-highlight'n };n }nn Swap.prototype = {n dragStart: function dragStart(_ref) {n var dragEl = _ref.dragEl;n lastSwapEl = dragEl;n },n dragOverValid: function dragOverValid(_ref2) {n var completed = _ref2.completed,n target = _ref2.target,n onMove = _ref2.onMove,n activeSortable = _ref2.activeSortable,n changed = _ref2.changed,n cancel = _ref2.cancel;n if (!activeSortable.options.swap) return;n var el = this.sortable.el,n options = this.options;nn if (target && target !== el) {n var prevSwapEl = lastSwapEl;nn if (onMove(target) !== false) {n toggleClass(target, options.swapClass, true);n lastSwapEl = target;n } else {n lastSwapEl = null;n }nn if (prevSwapEl && prevSwapEl !== lastSwapEl) {n toggleClass(prevSwapEl, options.swapClass, false);n }n }nn changed();n completed(true);n cancel();n },n drop: function drop(_ref3) {n var activeSortable = _ref3.activeSortable,n putSortable = _ref3.putSortable,n dragEl = _ref3.dragEl;n var toSortable = putSortable || this.sortable;n var options = this.options;n lastSwapEl && toggleClass(lastSwapEl, options.swapClass, false);nn if (lastSwapEl && (options.swap || putSortable && putSortable.options.swap)) {n if (dragEl !== lastSwapEl) {n toSortable.captureAnimationState();n if (toSortable !== activeSortable) activeSortable.captureAnimationState();n swapNodes(dragEl, lastSwapEl);n toSortable.animateAll();n if (toSortable !== activeSortable) activeSortable.animateAll();n }n }n },n nulling: function nulling() {n lastSwapEl = null;n }n };n return _extends(Swap, {n pluginName: 'swap',n eventProperties: function eventProperties() {n return {n swapItem: lastSwapEln };n }n });n}nnfunction swapNodes(n1, n2) {n var p1 = n1.parentNode,n p2 = n2.parentNode,n i1,n i2;n if (!p1 || !p2 || p1.isEqualNode(n2) || p2.isEqualNode(n1)) return;n i1 = index(n1);n i2 = index(n2);nn if (p1.isEqualNode(p2) && i1 < i2) {n i2++;n }nn p1.insertBefore(n2, p1.children);n p2.insertBefore(n1, p2.children);n}nnvar multiDragElements = [],n multiDragClones = [],n lastMultiDragSelect,n // for selection with modifier key down (SHIFT)nmultiDragSortable,n initialFolding = false,n // Initial multi-drag fold when drag startednfolding = false,n // Folding any other timendragStarted = false,n dragEl$1,n clonesFromRect,n clonesHidden;nnfunction MultiDragPlugin() {n function MultiDrag(sortable) {n // Bind all private methodsn for (var fn in this) {n if (fn.charAt(0) === '_' && typeof this === 'function') {n this = this.bind(this);n }n }nn if (sortable.options.supportPointer) {n on(document, 'pointerup', this._deselectMultiDrag);n } else {n on(document, 'mouseup', this._deselectMultiDrag);n on(document, 'touchend', this._deselectMultiDrag);n }nn on(document, 'keydown', this._checkKeyDown);n on(document, 'keyup', this._checkKeyUp);n this.defaults = {n selectedClass: 'sortable-selected',n multiDragKey: null,n setData: function setData(dataTransfer, dragEl) {n var data = '';nn if (multiDragElements.length && multiDragSortable === sortable) {n multiDragElements.forEach(function (multiDragElement, i) {n data += (!i ? '' : ', ') + multiDragElement.textContent;n });n } else {n data = dragEl.textContent;n }nn dataTransfer.setData('Text', data);n }n };n }nn MultiDrag.prototype = {n multiDragKeyDown: false,n isMultiDrag: false,n delayStartGlobal: function delayStartGlobal(_ref) {n var dragged = _ref.dragEl;n dragEl$1 = dragged;n },n delayEnded: function delayEnded() {n this.isMultiDrag = ~multiDragElements.indexOf(dragEl$1);n },n setupClone: function setupClone(_ref2) {n var sortable = _ref2.sortable,n cancel = _ref2.cancel;n if (!this.isMultiDrag) return;nn for (var i = 0; i < multiDragElements.length; i++) {n multiDragClones.push(clone(multiDragElements));n multiDragClones.sortableIndex = multiDragElements.sortableIndex;n multiDragClones.draggable = false;n multiDragClones.style = '';n toggleClass(multiDragClones, this.options.selectedClass, false);n multiDragElements === dragEl$1 && toggleClass(multiDragClones, this.options.chosenClass, false);n }nn sortable._hideClone();nn cancel();n },n clone: function clone(_ref3) {n var sortable = _ref3.sortable,n rootEl = _ref3.rootEl,n dispatchSortableEvent = _ref3.dispatchSortableEvent,n cancel = _ref3.cancel;n if (!this.isMultiDrag) return;nn if (!this.options.removeCloneOnHide) {n if (multiDragElements.length && multiDragSortable === sortable) {n insertMultiDragClones(true, rootEl);n dispatchSortableEvent('clone');n cancel();n }n }n },n showClone: function showClone(_ref4) {n var cloneNowShown = _ref4.cloneNowShown,n rootEl = _ref4.rootEl,n cancel = _ref4.cancel;n if (!this.isMultiDrag) return;n insertMultiDragClones(false, rootEl);n multiDragClones.forEach(function (clone) {n css(clone, 'display', '');n });n cloneNowShown();n clonesHidden = false;n cancel();n },n hideClone: function hideClone(_ref5) {n var _this = this;nn var sortable = _ref5.sortable,n cloneNowHidden = _ref5.cloneNowHidden,n cancel = _ref5.cancel;n if (!this.isMultiDrag) return;n multiDragClones.forEach(function (clone) {n css(clone, 'display', 'none');nn if (_this.options.removeCloneOnHide && clone.parentNode) {n clone.parentNode.removeChild(clone);n }n });n cloneNowHidden();n clonesHidden = true;n cancel();n },n dragStartGlobal: function dragStartGlobal(_ref6) {n var sortable = _ref6.sortable;nn if (!this.isMultiDrag && multiDragSortable) {n multiDragSortable.multiDrag._deselectMultiDrag();n }nn multiDragElements.forEach(function (multiDragElement) {n multiDragElement.sortableIndex = index(multiDragElement);n }); // Sort multi-drag elementsnn multiDragElements = multiDragElements.sort(function (a, b) {n return a.sortableIndex - b.sortableIndex;n });n dragStarted = true;n },n dragStarted: function dragStarted(_ref7) {n var _this2 = this;nn var sortable = _ref7.sortable;n if (!this.isMultiDrag) return;nn if (this.options.sort) {n // Capture rects,n // hide multi drag elements (by positioning them absolute),n // set multi drag elements rects to dragRect,n // show multi drag elements,n // animate to rects,n // unset rects & remove from DOMn sortable.captureAnimationState();nn if (this.options.animation) {n multiDragElements.forEach(function (multiDragElement) {n if (multiDragElement === dragEl$1) return;n css(multiDragElement, 'position', 'absolute');n });n var dragRect = getRect(dragEl$1, false, true, true);n multiDragElements.forEach(function (multiDragElement) {n if (multiDragElement === dragEl$1) return;n setRect(multiDragElement, dragRect);n });n folding = true;n initialFolding = true;n }n }nn sortable.animateAll(function () {n folding = false;n initialFolding = false;nn if (_this2.options.animation) {n multiDragElements.forEach(function (multiDragElement) {n unsetRect(multiDragElement);n });n } // Remove all auxiliary multidrag items from el, if sorting enablednnn if (_this2.options.sort) {n removeMultiDragElements();n }n });n },n dragOver: function dragOver(_ref8) {n var target = _ref8.target,n completed = _ref8.completed,n cancel = _ref8.cancel;nn if (folding && ~multiDragElements.indexOf(target)) {n completed(false);n cancel();n }n },n revert: function revert(_ref9) {n var fromSortable = _ref9.fromSortable,n rootEl = _ref9.rootEl,n sortable = _ref9.sortable,n dragRect = _ref9.dragRect;nn if (multiDragElements.length > 1) {n // Setup unfold animationn multiDragElements.forEach(function (multiDragElement) {n sortable.addAnimationState({n target: multiDragElement,n rect: folding ? getRect(multiDragElement) : dragRectn });n unsetRect(multiDragElement);n multiDragElement.fromRect = dragRect;n fromSortable.removeAnimationState(multiDragElement);n });n folding = false;n insertMultiDragElements(!this.options.removeCloneOnHide, rootEl);n }n },n dragOverCompleted: function dragOverCompleted(_ref10) {n var sortable = _ref10.sortable,n isOwner = _ref10.isOwner,n insertion = _ref10.insertion,n activeSortable = _ref10.activeSortable,n parentEl = _ref10.parentEl,n putSortable = _ref10.putSortable;n var options = this.options;nn if (insertion) {n // Clones must be hidden before folding animation to capture dragRectAbsolute properlyn if (isOwner) {n activeSortable._hideClone();n }nn initialFolding = false; // If leaving sort:false root, or already folding - Fold to new locationnn if (options.animation && multiDragElements.length > 1 && (folding || !isOwner && !activeSortable.options.sort && !putSortable)) {n // Fold: Set all multi drag elements's rects to dragEl's rect when multi-drag elements are invisiblen var dragRectAbsolute = getRect(dragEl$1, false, true, true);n multiDragElements.forEach(function (multiDragElement) {n if (multiDragElement === dragEl$1) return;n setRect(multiDragElement, dragRectAbsolute); // Move element(s) to end of parentEl so that it does not interfere with multi-drag clones insertion if they are insertedn // while folding, and so that we can capture them again because old sortable will no longer be fromSortablenn parentEl.appendChild(multiDragElement);n });n folding = true;n } // Clones must be shown (and check to remove multi drags) after folding when interfering multiDragElements are moved outnnn if (!isOwner) {n // Only remove if not folding (folding will remove them anyways)n if (!folding) {n removeMultiDragElements();n }nn if (multiDragElements.length > 1) {n var clonesHiddenBefore = clonesHidden;nn activeSortable._showClone(sortable); // Unfold animation for clones if showing from hiddennnn if (activeSortable.options.animation && !clonesHidden && clonesHiddenBefore) {n multiDragClones.forEach(function (clone) {n activeSortable.addAnimationState({n target: clone,n rect: clonesFromRectn });n clone.fromRect = clonesFromRect;n clone.thisAnimationDuration = null;n });n }n } else {n activeSortable._showClone(sortable);n }n }n }n },n dragOverAnimationCapture: function dragOverAnimationCapture(_ref11) {n var dragRect = _ref11.dragRect,n isOwner = _ref11.isOwner,n activeSortable = _ref11.activeSortable;n multiDragElements.forEach(function (multiDragElement) {n multiDragElement.thisAnimationDuration = null;n });nn if (activeSortable.options.animation && !isOwner && activeSortable.multiDrag.isMultiDrag) {n clonesFromRect = _extends({}, dragRect);n var dragMatrix = matrix(dragEl$1, true);n clonesFromRect.top -= dragMatrix.f;n clonesFromRect.left -= dragMatrix.e;n }n },n dragOverAnimationComplete: function dragOverAnimationComplete() {n if (folding) {n folding = false;n removeMultiDragElements();n }n },n drop: function drop(_ref12) {n var evt = _ref12.originalEvent,n rootEl = _ref12.rootEl,n parentEl = _ref12.parentEl,n sortable = _ref12.sortable,n dispatchSortableEvent = _ref12.dispatchSortableEvent,n oldIndex = _ref12.oldIndex,n putSortable = _ref12.putSortable;n var toSortable = putSortable || this.sortable;n if (!evt) return;n var options = this.options,n children = parentEl.children; // Multi-drag selectionnn if (!dragStarted) {n if (options.multiDragKey && !this.multiDragKeyDown) {n this._deselectMultiDrag();n }nn toggleClass(dragEl$1, options.selectedClass, !~multiDragElements.indexOf(dragEl$1));nn if (!~multiDragElements.indexOf(dragEl$1)) {n multiDragElements.push(dragEl$1);n dispatchEvent({n sortable: sortable,n rootEl: rootEl,n name: 'select',n targetEl: dragEl$1,n originalEvt: evtn }); // Modifier activated, select from last to dragElnn if (evt.shiftKey && lastMultiDragSelect && sortable.el.contains(lastMultiDragSelect)) {n var lastIndex = index(lastMultiDragSelect),n currentIndex = index(dragEl$1);nn if (~lastIndex && ~currentIndex && lastIndex !== currentIndex) {n // Must include lastMultiDragSelect (select it), in case modified selection from no selectionn // (but previous selection existed)n var n, i;nn if (currentIndex > lastIndex) {n i = lastIndex;n n = currentIndex;n } else {n i = currentIndex;n n = lastIndex + 1;n }nn for (; i < n; i++) {n if (~multiDragElements.indexOf(children)) continue;n toggleClass(children, options.selectedClass, true);n multiDragElements.push(children);n dispatchEvent({n sortable: sortable,n rootEl: rootEl,n name: 'select',n targetEl: children,n originalEvt: evtn });n }n }n } else {n lastMultiDragSelect = dragEl$1;n }nn multiDragSortable = toSortable;n } else {n multiDragElements.splice(multiDragElements.indexOf(dragEl$1), 1);n lastMultiDragSelect = null;n dispatchEvent({n sortable: sortable,n rootEl: rootEl,n name: 'deselect',n targetEl: dragEl$1,n originalEvt: evtn });n }n } // Multi-drag dropnnn if (dragStarted && this.isMultiDrag) {n // Do not "unfold" after around dragEl if revertedn if ((parentEl.options.sort || parentEl !== rootEl) && multiDragElements.length > 1) {n var dragRect = getRect(dragEl$1),n multiDragIndex = index(dragEl$1, ':not(.' + this.options.selectedClass + ')');n if (!initialFolding && options.animation) dragEl$1.thisAnimationDuration = null;n toSortable.captureAnimationState();nn if (!initialFolding) {n if (options.animation) {n dragEl$1.fromRect = dragRect;n multiDragElements.forEach(function (multiDragElement) {n multiDragElement.thisAnimationDuration = null;nn if (multiDragElement !== dragEl$1) {n var rect = folding ? getRect(multiDragElement) : dragRect;n multiDragElement.fromRect = rect; // Prepare unfold animationnn toSortable.addAnimationState({n target: multiDragElement,n rect: rectn });n }n });n } // Multi drag elements are not necessarily removed from the DOM on drop, so to reinsertn // properly they must all be removednnn removeMultiDragElements();n multiDragElements.forEach(function (multiDragElement) {n if (children) {n parentEl.insertBefore(multiDragElement, children);n } else {n parentEl.appendChild(multiDragElement);n }nn multiDragIndex++;n }); // If initial folding is done, the elements may have changed position because they are nown // unfolding around dragEl, even though dragEl may not have his index changed, so update eventn // must be fired here as Sortable will not.nn if (oldIndex === index(dragEl$1)) {n var update = false;n multiDragElements.forEach(function (multiDragElement) {n if (multiDragElement.sortableIndex !== index(multiDragElement)) {n update = true;n return;n }n });nn if (update) {n dispatchSortableEvent('update');n }n }n } // Must be done after capturing individual rects (scroll bar)nnn multiDragElements.forEach(function (multiDragElement) {n unsetRect(multiDragElement);n });n toSortable.animateAll();n }nn multiDragSortable = toSortable;n } // Remove clones if necessarynnn if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') {n multiDragClones.forEach(function (clone) {n clone.parentNode && clone.parentNode.removeChild(clone);n });n }n },n nullingGlobal: function nullingGlobal() {n this.isMultiDrag = dragStarted = false;n multiDragClones.length = 0;n },n destroyGlobal: function destroyGlobal() {n this._deselectMultiDrag();nn off(document, 'pointerup', this._deselectMultiDrag);n off(document, 'mouseup', this._deselectMultiDrag);n off(document, 'touchend', this._deselectMultiDrag);n off(document, 'keydown', this._checkKeyDown);n off(document, 'keyup', this._checkKeyUp);n },n _deselectMultiDrag: function _deselectMultiDrag(evt) {n if (dragStarted) return; // Only deselect if selection is in this sortablenn if (multiDragSortable !== this.sortable) return; // Only deselect if target is not item in this sortablenn if (evt && closest(evt.target, this.options.draggable, this.sortable.el, false)) return; // Only deselect if left clicknn if (evt && evt.button !== 0) return;nn while (multiDragElements.length) {n var el = multiDragElements;n toggleClass(el, this.options.selectedClass, false);n multiDragElements.shift();n dispatchEvent({n sortable: this.sortable,n rootEl: this.sortable.el,n name: 'deselect',n targetEl: el,n originalEvt: evtn });n }n },n _checkKeyDown: function _checkKeyDown(evt) {n if (evt.key === this.options.multiDragKey) {n this.multiDragKeyDown = true;n }n },n _checkKeyUp: function _checkKeyUp(evt) {n if (evt.key === this.options.multiDragKey) {n this.multiDragKeyDown = false;n }n }n };n return _extends(MultiDrag, {n // Static methods & propertiesn pluginName: 'multiDrag',n utils: {n /**n * Selects the provided multi-drag itemn * @param {HTMLElement} el The element to be selectedn */n select: function select(el) {n var sortable = el.parentNode;n if (!sortable || !sortable.options.multiDrag || ~multiDragElements.indexOf(el)) return;nn if (multiDragSortable && multiDragSortable !== sortable) {n multiDragSortable.multiDrag._deselectMultiDrag();nn multiDragSortable = sortable;n }nn toggleClass(el, sortable.options.selectedClass, true);n multiDragElements.push(el);n },nn /**n * Deselects the provided multi-drag itemn * @param {HTMLElement} el The element to be deselectedn */n deselect: function deselect(el) {n var sortable = el.parentNode,n index = multiDragElements.indexOf(el);n if (!sortable || !sortable.options.multiDrag || !~index) return;n toggleClass(el, sortable.options.selectedClass, false);n multiDragElements.splice(index, 1);n }n },n eventProperties: function eventProperties() {n var _this3 = this;nn var oldIndicies = [],n newIndicies = [];n multiDragElements.forEach(function (multiDragElement) {n oldIndicies.push({n multiDragElement: multiDragElement,n index: multiDragElement.sortableIndexn }); // multiDragElements will already be sorted if foldingnn var newIndex;nn if (folding && multiDragElement !== dragEl$1) {n newIndex = -1;n } else if (folding) {n newIndex = index(multiDragElement, ':not(.' + _this3.options.selectedClass + ')');n } else {n newIndex = index(multiDragElement);n }nn newIndicies.push({n multiDragElement: multiDragElement,n index: newIndexn });n });n return {n items: _toConsumableArray(multiDragElements),n clones: [].concat(multiDragClones),n oldIndicies: oldIndicies,n newIndicies: newIndiciesn };n },n optionListeners: {n multiDragKey: function multiDragKey(key) {n key = key.toLowerCase();nn if (key === 'ctrl') {n key = 'Control';n } else if (key.length > 1) {n key = key.charAt(0).toUpperCase() + key.substr(1);n }nn return key;n }n }n });n}nnfunction insertMultiDragElements(clonesInserted, rootEl) {n multiDragElements.forEach(function (multiDragElement, i) {n var target = rootEl.children[multiDragElement.sortableIndex + (clonesInserted ? Number(i) : 0)];nn if (target) {n rootEl.insertBefore(multiDragElement, target);n } else {n rootEl.appendChild(multiDragElement);n }n });n}n/**n * Insert multi-drag clonesn * @param {[Boolean]} elementsInserted Whether the multi-drag elements are insertedn * @param {HTMLElement} rootEln */nnnfunction insertMultiDragClones(elementsInserted, rootEl) {n multiDragClones.forEach(function (clone, i) {n var target = rootEl.children[clone.sortableIndex + (elementsInserted ? Number(i) : 0)];nn if (target) {n rootEl.insertBefore(clone, target);n } else {n rootEl.appendChild(clone);n }n });n}nnfunction removeMultiDragElements() {n multiDragElements.forEach(function (multiDragElement) {n if (multiDragElement === dragEl$1) return;n multiDragElement.parentNode && multiDragElement.parentNode.removeChild(multiDragElement);n });n}nnSortable.mount(new AutoScrollPlugin());nSortable.mount(Remove, Revert);nexport default Sortable;nexport { MultiDragPlugin as MultiDrag, Sortable, SwapPlugin as Swap };”,“map”:null,“metadata”:{},“sourceType”:“module”}