|
|
@@ -0,0 +1,2607 @@
|
|
|
+/*! Sortable 1.13.0 - MIT | git://github.com/SortableJS/Sortable.git */
|
|
|
+!(function (t, e) {
|
|
|
+ "object" == typeof exports && "undefined" != typeof module
|
|
|
+ ? (module.exports = e())
|
|
|
+ : "function" == typeof define && define.amd
|
|
|
+ ? define(e)
|
|
|
+ : ((t = t || self).Sortable = e());
|
|
|
+})(this, function () {
|
|
|
+ "use strict";
|
|
|
+ function o(t) {
|
|
|
+ return (o =
|
|
|
+ "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
|
|
|
+ ? function (t) {
|
|
|
+ return typeof t;
|
|
|
+ }
|
|
|
+ : function (t) {
|
|
|
+ return t &&
|
|
|
+ "function" == typeof Symbol &&
|
|
|
+ t.constructor === Symbol &&
|
|
|
+ t !== Symbol.prototype
|
|
|
+ ? "symbol"
|
|
|
+ : typeof t;
|
|
|
+ })(t);
|
|
|
+ }
|
|
|
+ function a() {
|
|
|
+ return (a =
|
|
|
+ Object.assign ||
|
|
|
+ function (t) {
|
|
|
+ for (var e = 1; e < arguments.length; e++) {
|
|
|
+ var n = arguments[e];
|
|
|
+ for (var o in n)
|
|
|
+ Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
|
|
|
+ }
|
|
|
+ return t;
|
|
|
+ }).apply(this, arguments);
|
|
|
+ }
|
|
|
+ function I(i) {
|
|
|
+ for (var t = 1; t < arguments.length; t++) {
|
|
|
+ var r = null != arguments[t] ? arguments[t] : {},
|
|
|
+ e = Object.keys(r);
|
|
|
+ "function" == typeof Object.getOwnPropertySymbols &&
|
|
|
+ (e = e.concat(
|
|
|
+ Object.getOwnPropertySymbols(r).filter(function (t) {
|
|
|
+ return Object.getOwnPropertyDescriptor(r, t).enumerable;
|
|
|
+ })
|
|
|
+ )),
|
|
|
+ e.forEach(function (t) {
|
|
|
+ var e, n, o;
|
|
|
+ (e = i),
|
|
|
+ (o = r[(n = t)]),
|
|
|
+ n in e
|
|
|
+ ? Object.defineProperty(e, n, {
|
|
|
+ value: o,
|
|
|
+ enumerable: !0,
|
|
|
+ configurable: !0,
|
|
|
+ writable: !0
|
|
|
+ })
|
|
|
+ : (e[n] = o);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+ }
|
|
|
+ function l(t, e) {
|
|
|
+ if (null == t) return {};
|
|
|
+ var n,
|
|
|
+ o,
|
|
|
+ i = (function (t, e) {
|
|
|
+ if (null == t) return {};
|
|
|
+ var n,
|
|
|
+ o,
|
|
|
+ i = {},
|
|
|
+ r = Object.keys(t);
|
|
|
+ for (o = 0; o < r.length; o++)
|
|
|
+ (n = r[o]), 0 <= e.indexOf(n) || (i[n] = t[n]);
|
|
|
+ return i;
|
|
|
+ })(t, e);
|
|
|
+ if (Object.getOwnPropertySymbols) {
|
|
|
+ var r = Object.getOwnPropertySymbols(t);
|
|
|
+ for (o = 0; o < r.length; o++)
|
|
|
+ (n = r[o]),
|
|
|
+ 0 <= e.indexOf(n) ||
|
|
|
+ (Object.prototype.propertyIsEnumerable.call(t, n) && (i[n] = t[n]));
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+ }
|
|
|
+ function e(t) {
|
|
|
+ return (
|
|
|
+ (function (t) {
|
|
|
+ if (Array.isArray(t)) {
|
|
|
+ for (var e = 0, n = new Array(t.length); e < t.length; e++)
|
|
|
+ n[e] = t[e];
|
|
|
+ return n;
|
|
|
+ }
|
|
|
+ })(t) ||
|
|
|
+ (function (t) {
|
|
|
+ if (
|
|
|
+ Symbol.iterator in Object(t) ||
|
|
|
+ "[object Arguments]" === Object.prototype.toString.call(t)
|
|
|
+ )
|
|
|
+ return Array.from(t);
|
|
|
+ })(t) ||
|
|
|
+ (function () {
|
|
|
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
|
|
|
+ })()
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function t(t) {
|
|
|
+ if ("undefined" != typeof window && window.navigator)
|
|
|
+ return !!navigator.userAgent.match(t);
|
|
|
+ }
|
|
|
+ var w = t(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i),
|
|
|
+ E = t(/Edge/i),
|
|
|
+ c = t(/firefox/i),
|
|
|
+ u = t(/safari/i) && !t(/chrome/i) && !t(/android/i),
|
|
|
+ n = t(/iP(ad|od|hone)/i),
|
|
|
+ i = t(/chrome/i) && t(/android/i),
|
|
|
+ r = { capture: !1, passive: !1 };
|
|
|
+ function d(t, e, n) {
|
|
|
+ t.addEventListener(e, n, !w && r);
|
|
|
+ }
|
|
|
+ function s(t, e, n) {
|
|
|
+ t.removeEventListener(e, n, !w && r);
|
|
|
+ }
|
|
|
+ function h(t, e) {
|
|
|
+ if (e) {
|
|
|
+ if ((">" === e[0] && (e = e.substring(1)), t))
|
|
|
+ try {
|
|
|
+ if (t.matches) return t.matches(e);
|
|
|
+ if (t.msMatchesSelector) return t.msMatchesSelector(e);
|
|
|
+ if (t.webkitMatchesSelector) return t.webkitMatchesSelector(e);
|
|
|
+ } catch (t) {
|
|
|
+ return !1;
|
|
|
+ }
|
|
|
+ return !1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function P(t, e, n, o) {
|
|
|
+ if (t) {
|
|
|
+ n = n || document;
|
|
|
+ do {
|
|
|
+ if (
|
|
|
+ (null != e &&
|
|
|
+ (">" === e[0] ? t.parentNode === n && h(t, e) : h(t, e))) ||
|
|
|
+ (o && t === n)
|
|
|
+ )
|
|
|
+ return t;
|
|
|
+ if (t === n) break;
|
|
|
+ } while (
|
|
|
+ (t =
|
|
|
+ (i = t).host && i !== document && i.host.nodeType
|
|
|
+ ? i.host
|
|
|
+ : i.parentNode)
|
|
|
+ );
|
|
|
+ }
|
|
|
+ var i;
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var f,
|
|
|
+ p = /\s+/g;
|
|
|
+ function k(t, e, n) {
|
|
|
+ if (t && e)
|
|
|
+ if (t.classList) t.classList[n ? "add" : "remove"](e);
|
|
|
+ else {
|
|
|
+ var o = (" " + t.className + " ")
|
|
|
+ .replace(p, " ")
|
|
|
+ .replace(" " + e + " ", " ");
|
|
|
+ t.className = (o + (n ? " " + e : "")).replace(p, " ");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function R(t, e, n) {
|
|
|
+ var o = t && t.style;
|
|
|
+ if (o) {
|
|
|
+ if (void 0 === n)
|
|
|
+ return (
|
|
|
+ document.defaultView && document.defaultView.getComputedStyle
|
|
|
+ ? (n = document.defaultView.getComputedStyle(t, ""))
|
|
|
+ : t.currentStyle && (n = t.currentStyle),
|
|
|
+ void 0 === e ? n : n[e]
|
|
|
+ );
|
|
|
+ e in o || -1 !== e.indexOf("webkit") || (e = "-webkit-" + e),
|
|
|
+ (o[e] = n + ("string" == typeof n ? "" : "px"));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function v(t, e) {
|
|
|
+ var n = "";
|
|
|
+ if ("string" == typeof t) n = t;
|
|
|
+ else
|
|
|
+ do {
|
|
|
+ var o = R(t, "transform");
|
|
|
+ o && "none" !== o && (n = o + " " + n);
|
|
|
+ } while (!e && (t = t.parentNode));
|
|
|
+ var i =
|
|
|
+ window.DOMMatrix ||
|
|
|
+ window.WebKitCSSMatrix ||
|
|
|
+ window.CSSMatrix ||
|
|
|
+ window.MSCSSMatrix;
|
|
|
+ return i && new i(n);
|
|
|
+ }
|
|
|
+ function g(t, e, n) {
|
|
|
+ if (t) {
|
|
|
+ var o = t.getElementsByTagName(e),
|
|
|
+ i = 0,
|
|
|
+ r = o.length;
|
|
|
+ if (n) for (; i < r; i++) n(o[i], i);
|
|
|
+ return o;
|
|
|
+ }
|
|
|
+ return [];
|
|
|
+ }
|
|
|
+ function A() {
|
|
|
+ var t = document.scrollingElement;
|
|
|
+ return t || document.documentElement;
|
|
|
+ }
|
|
|
+ function X(t, e, n, o, i) {
|
|
|
+ if (t.getBoundingClientRect || t === window) {
|
|
|
+ var r, a, l, s, c, u, d;
|
|
|
+ if (
|
|
|
+ ((d =
|
|
|
+ t !== window && t.parentNode && t !== A()
|
|
|
+ ? ((a = (r = t.getBoundingClientRect()).top),
|
|
|
+ (l = r.left),
|
|
|
+ (s = r.bottom),
|
|
|
+ (c = r.right),
|
|
|
+ (u = r.height),
|
|
|
+ r.width)
|
|
|
+ : ((l = a = 0),
|
|
|
+ (s = window.innerHeight),
|
|
|
+ (c = window.innerWidth),
|
|
|
+ (u = window.innerHeight),
|
|
|
+ window.innerWidth)),
|
|
|
+ (e || n) && t !== window && ((i = i || t.parentNode), !w))
|
|
|
+ )
|
|
|
+ do {
|
|
|
+ if (
|
|
|
+ i &&
|
|
|
+ i.getBoundingClientRect &&
|
|
|
+ ("none" !== R(i, "transform") ||
|
|
|
+ (n && "static" !== R(i, "position")))
|
|
|
+ ) {
|
|
|
+ var h = i.getBoundingClientRect();
|
|
|
+ (a -= h.top + parseInt(R(i, "border-top-width"))),
|
|
|
+ (l -= h.left + parseInt(R(i, "border-left-width"))),
|
|
|
+ (s = a + r.height),
|
|
|
+ (c = l + r.width);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ } while ((i = i.parentNode));
|
|
|
+ if (o && t !== window) {
|
|
|
+ var f = v(i || t),
|
|
|
+ p = f && f.a,
|
|
|
+ g = f && f.d;
|
|
|
+ f && ((s = (a /= g) + (u /= g)), (c = (l /= p) + (d /= p)));
|
|
|
+ }
|
|
|
+ return { top: a, left: l, bottom: s, right: c, width: d, height: u };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Y(t, e, n) {
|
|
|
+ for (var o = H(t, !0), i = X(t)[e]; o; ) {
|
|
|
+ var r = X(o)[n];
|
|
|
+ if (!("top" === n || "left" === n ? r <= i : i <= r)) return o;
|
|
|
+ if (o === A()) break;
|
|
|
+ o = H(o, !1);
|
|
|
+ }
|
|
|
+ return !1;
|
|
|
+ }
|
|
|
+ function m(t, e, n) {
|
|
|
+ for (var o = 0, i = 0, r = t.children; i < r.length; ) {
|
|
|
+ if (
|
|
|
+ "none" !== r[i].style.display &&
|
|
|
+ r[i] !== Rt.ghost &&
|
|
|
+ r[i] !== Rt.dragged &&
|
|
|
+ P(r[i], n.draggable, t, !1)
|
|
|
+ ) {
|
|
|
+ if (o === e) return r[i];
|
|
|
+ o++;
|
|
|
+ }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ function B(t, e) {
|
|
|
+ for (
|
|
|
+ var n = t.lastElementChild;
|
|
|
+ n && (n === Rt.ghost || "none" === R(n, "display") || (e && !h(n, e)));
|
|
|
+
|
|
|
+ )
|
|
|
+ n = n.previousElementSibling;
|
|
|
+ return n || null;
|
|
|
+ }
|
|
|
+ function F(t, e) {
|
|
|
+ var n = 0;
|
|
|
+ if (!t || !t.parentNode) return -1;
|
|
|
+ for (; (t = t.previousElementSibling); )
|
|
|
+ "TEMPLATE" === t.nodeName.toUpperCase() ||
|
|
|
+ t === Rt.clone ||
|
|
|
+ (e && !h(t, e)) ||
|
|
|
+ n++;
|
|
|
+ return n;
|
|
|
+ }
|
|
|
+ function b(t) {
|
|
|
+ var e = 0,
|
|
|
+ n = 0,
|
|
|
+ o = A();
|
|
|
+ if (t)
|
|
|
+ do {
|
|
|
+ var i = v(t),
|
|
|
+ r = i.a,
|
|
|
+ a = i.d;
|
|
|
+ (e += t.scrollLeft * r), (n += t.scrollTop * a);
|
|
|
+ } while (t !== o && (t = t.parentNode));
|
|
|
+ return [e, n];
|
|
|
+ }
|
|
|
+ function H(t, e) {
|
|
|
+ if (!t || !t.getBoundingClientRect) return A();
|
|
|
+ var n = t,
|
|
|
+ o = !1;
|
|
|
+ do {
|
|
|
+ if (n.clientWidth < n.scrollWidth || n.clientHeight < n.scrollHeight) {
|
|
|
+ var i = R(n);
|
|
|
+ if (
|
|
|
+ (n.clientWidth < n.scrollWidth &&
|
|
|
+ ("auto" == i.overflowX || "scroll" == i.overflowX)) ||
|
|
|
+ (n.clientHeight < n.scrollHeight &&
|
|
|
+ ("auto" == i.overflowY || "scroll" == i.overflowY))
|
|
|
+ ) {
|
|
|
+ if (!n.getBoundingClientRect || n === document.body) return A();
|
|
|
+ if (o || e) return n;
|
|
|
+ o = !0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while ((n = n.parentNode));
|
|
|
+ return A();
|
|
|
+ }
|
|
|
+ function y(t, e) {
|
|
|
+ return (
|
|
|
+ Math.round(t.top) === Math.round(e.top) &&
|
|
|
+ Math.round(t.left) === Math.round(e.left) &&
|
|
|
+ Math.round(t.height) === Math.round(e.height) &&
|
|
|
+ Math.round(t.width) === Math.round(e.width)
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function D(e, n) {
|
|
|
+ return function () {
|
|
|
+ if (!f) {
|
|
|
+ var t = arguments;
|
|
|
+ 1 === t.length ? e.call(this, t[0]) : e.apply(this, t),
|
|
|
+ (f = setTimeout(function () {
|
|
|
+ f = void 0;
|
|
|
+ }, n));
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }
|
|
|
+ function L(t, e, n) {
|
|
|
+ (t.scrollLeft += e), (t.scrollTop += n);
|
|
|
+ }
|
|
|
+ function S(t) {
|
|
|
+ var e = window.Polymer,
|
|
|
+ n = window.jQuery || window.Zepto;
|
|
|
+ return e && e.dom
|
|
|
+ ? e.dom(t).cloneNode(!0)
|
|
|
+ : n
|
|
|
+ ? n(t).clone(!0)[0]
|
|
|
+ : t.cloneNode(!0);
|
|
|
+ }
|
|
|
+ function _(t, e) {
|
|
|
+ R(t, "position", "absolute"),
|
|
|
+ R(t, "top", e.top),
|
|
|
+ R(t, "left", e.left),
|
|
|
+ R(t, "width", e.width),
|
|
|
+ R(t, "height", e.height);
|
|
|
+ }
|
|
|
+ function C(t) {
|
|
|
+ R(t, "position", ""),
|
|
|
+ R(t, "top", ""),
|
|
|
+ R(t, "left", ""),
|
|
|
+ R(t, "width", ""),
|
|
|
+ R(t, "height", "");
|
|
|
+ }
|
|
|
+ var j = "Sortable" + new Date().getTime();
|
|
|
+ function T() {
|
|
|
+ var e,
|
|
|
+ o = [];
|
|
|
+ return {
|
|
|
+ captureAnimationState: function () {
|
|
|
+ (o = []),
|
|
|
+ this.options.animation &&
|
|
|
+ [].slice.call(this.el.children).forEach(function (t) {
|
|
|
+ if ("none" !== R(t, "display") && t !== Rt.ghost) {
|
|
|
+ o.push({ target: t, rect: X(t) });
|
|
|
+ var e = I({}, o[o.length - 1].rect);
|
|
|
+ if (t.thisAnimationDuration) {
|
|
|
+ var n = v(t, !0);
|
|
|
+ n && ((e.top -= n.f), (e.left -= n.e));
|
|
|
+ }
|
|
|
+ t.fromRect = e;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ },
|
|
|
+ addAnimationState: function (t) {
|
|
|
+ o.push(t);
|
|
|
+ },
|
|
|
+ removeAnimationState: function (t) {
|
|
|
+ o.splice(
|
|
|
+ (function (t, e) {
|
|
|
+ for (var n in t)
|
|
|
+ if (t.hasOwnProperty(n))
|
|
|
+ for (var o in e)
|
|
|
+ if (e.hasOwnProperty(o) && e[o] === t[n][o]) return Number(n);
|
|
|
+ return -1;
|
|
|
+ })(o, { target: t }),
|
|
|
+ 1
|
|
|
+ );
|
|
|
+ },
|
|
|
+ animateAll: function (t) {
|
|
|
+ var c = this;
|
|
|
+ if (!this.options.animation)
|
|
|
+ return clearTimeout(e), void ("function" == typeof t && t());
|
|
|
+ var u = !1,
|
|
|
+ d = 0;
|
|
|
+ o.forEach(function (t) {
|
|
|
+ var e = 0,
|
|
|
+ n = t.target,
|
|
|
+ o = n.fromRect,
|
|
|
+ i = X(n),
|
|
|
+ r = n.prevFromRect,
|
|
|
+ a = n.prevToRect,
|
|
|
+ l = t.rect,
|
|
|
+ s = v(n, !0);
|
|
|
+ s && ((i.top -= s.f), (i.left -= s.e)),
|
|
|
+ (n.toRect = i),
|
|
|
+ n.thisAnimationDuration &&
|
|
|
+ y(r, i) &&
|
|
|
+ !y(o, i) &&
|
|
|
+ (l.top - i.top) / (l.left - i.left) ==
|
|
|
+ (o.top - i.top) / (o.left - i.left) &&
|
|
|
+ (e = (function (t, e, n, o) {
|
|
|
+ return (
|
|
|
+ (Math.sqrt(
|
|
|
+ Math.pow(e.top - t.top, 2) + Math.pow(e.left - t.left, 2)
|
|
|
+ ) /
|
|
|
+ Math.sqrt(
|
|
|
+ Math.pow(e.top - n.top, 2) + Math.pow(e.left - n.left, 2)
|
|
|
+ )) *
|
|
|
+ o.animation
|
|
|
+ );
|
|
|
+ })(l, r, a, c.options)),
|
|
|
+ y(i, o) ||
|
|
|
+ ((n.prevFromRect = o),
|
|
|
+ (n.prevToRect = i),
|
|
|
+ e || (e = c.options.animation),
|
|
|
+ c.animate(n, l, i, e)),
|
|
|
+ e &&
|
|
|
+ ((u = !0),
|
|
|
+ (d = Math.max(d, e)),
|
|
|
+ clearTimeout(n.animationResetTimer),
|
|
|
+ (n.animationResetTimer = setTimeout(function () {
|
|
|
+ (n.animationTime = 0),
|
|
|
+ (n.prevFromRect = null),
|
|
|
+ (n.fromRect = null),
|
|
|
+ (n.prevToRect = null),
|
|
|
+ (n.thisAnimationDuration = null);
|
|
|
+ }, e)),
|
|
|
+ (n.thisAnimationDuration = e));
|
|
|
+ }),
|
|
|
+ clearTimeout(e),
|
|
|
+ u
|
|
|
+ ? (e = setTimeout(function () {
|
|
|
+ "function" == typeof t && t();
|
|
|
+ }, d))
|
|
|
+ : "function" == typeof t && t(),
|
|
|
+ (o = []);
|
|
|
+ },
|
|
|
+ animate: function (t, e, n, o) {
|
|
|
+ if (o) {
|
|
|
+ R(t, "transition", ""), R(t, "transform", "");
|
|
|
+ var i = v(this.el),
|
|
|
+ r = i && i.a,
|
|
|
+ a = i && i.d,
|
|
|
+ l = (e.left - n.left) / (r || 1),
|
|
|
+ s = (e.top - n.top) / (a || 1);
|
|
|
+ (t.animatingX = !!l),
|
|
|
+ (t.animatingY = !!s),
|
|
|
+ R(t, "transform", "translate3d(" + l + "px," + s + "px,0)"),
|
|
|
+ (this.forRepaintDummy = (function (t) {
|
|
|
+ return t.offsetWidth;
|
|
|
+ })(t)),
|
|
|
+ R(
|
|
|
+ t,
|
|
|
+ "transition",
|
|
|
+ "transform " +
|
|
|
+ o +
|
|
|
+ "ms" +
|
|
|
+ (this.options.easing ? " " + this.options.easing : "")
|
|
|
+ ),
|
|
|
+ R(t, "transform", "translate3d(0,0,0)"),
|
|
|
+ "number" == typeof t.animated && clearTimeout(t.animated),
|
|
|
+ (t.animated = setTimeout(function () {
|
|
|
+ R(t, "transition", ""),
|
|
|
+ R(t, "transform", ""),
|
|
|
+ (t.animated = !1),
|
|
|
+ (t.animatingX = !1),
|
|
|
+ (t.animatingY = !1);
|
|
|
+ }, o));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }
|
|
|
+ var x = [],
|
|
|
+ M = { initializeByDefault: !0 },
|
|
|
+ O = {
|
|
|
+ mount: function (e) {
|
|
|
+ for (var t in M) !M.hasOwnProperty(t) || t in e || (e[t] = M[t]);
|
|
|
+ x.forEach(function (t) {
|
|
|
+ if (t.pluginName === e.pluginName)
|
|
|
+ throw "Sortable: Cannot mount plugin ".concat(
|
|
|
+ e.pluginName,
|
|
|
+ " more than once"
|
|
|
+ );
|
|
|
+ }),
|
|
|
+ x.push(e);
|
|
|
+ },
|
|
|
+ pluginEvent: function (e, n, o) {
|
|
|
+ var t = this;
|
|
|
+ (this.eventCanceled = !1),
|
|
|
+ (o.cancel = function () {
|
|
|
+ t.eventCanceled = !0;
|
|
|
+ });
|
|
|
+ var i = e + "Global";
|
|
|
+ x.forEach(function (t) {
|
|
|
+ n[t.pluginName] &&
|
|
|
+ (n[t.pluginName][i] && n[t.pluginName][i](I({ sortable: n }, o)),
|
|
|
+ n.options[t.pluginName] &&
|
|
|
+ n[t.pluginName][e] &&
|
|
|
+ n[t.pluginName][e](I({ sortable: n }, o)));
|
|
|
+ });
|
|
|
+ },
|
|
|
+ initializePlugins: function (o, i, r, t) {
|
|
|
+ for (var e in (x.forEach(function (t) {
|
|
|
+ var e = t.pluginName;
|
|
|
+ if (o.options[e] || t.initializeByDefault) {
|
|
|
+ var n = new t(o, i, o.options);
|
|
|
+ (n.sortable = o),
|
|
|
+ (n.options = o.options),
|
|
|
+ (o[e] = n),
|
|
|
+ a(r, n.defaults);
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ o.options))
|
|
|
+ if (o.options.hasOwnProperty(e)) {
|
|
|
+ var n = this.modifyOption(o, e, o.options[e]);
|
|
|
+ void 0 !== n && (o.options[e] = n);
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getEventProperties: function (e, n) {
|
|
|
+ var o = {};
|
|
|
+ return (
|
|
|
+ x.forEach(function (t) {
|
|
|
+ "function" == typeof t.eventProperties &&
|
|
|
+ a(o, t.eventProperties.call(n[t.pluginName], e));
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ );
|
|
|
+ },
|
|
|
+ modifyOption: function (e, n, o) {
|
|
|
+ var i;
|
|
|
+ return (
|
|
|
+ x.forEach(function (t) {
|
|
|
+ e[t.pluginName] &&
|
|
|
+ t.optionListeners &&
|
|
|
+ "function" == typeof t.optionListeners[n] &&
|
|
|
+ (i = t.optionListeners[n].call(e[t.pluginName], o));
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ );
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function N(t) {
|
|
|
+ var e = t.sortable,
|
|
|
+ n = t.rootEl,
|
|
|
+ o = t.name,
|
|
|
+ i = t.targetEl,
|
|
|
+ r = t.cloneEl,
|
|
|
+ a = t.toEl,
|
|
|
+ l = t.fromEl,
|
|
|
+ s = t.oldIndex,
|
|
|
+ c = t.newIndex,
|
|
|
+ u = t.oldDraggableIndex,
|
|
|
+ d = t.newDraggableIndex,
|
|
|
+ h = t.originalEvent,
|
|
|
+ f = t.putSortable,
|
|
|
+ p = t.extraEventProperties;
|
|
|
+ if ((e = e || (n && n[j]))) {
|
|
|
+ var g,
|
|
|
+ v = e.options,
|
|
|
+ m = "on" + o.charAt(0).toUpperCase() + o.substr(1);
|
|
|
+ !window.CustomEvent || w || E
|
|
|
+ ? (g = document.createEvent("Event")).initEvent(o, !0, !0)
|
|
|
+ : (g = new CustomEvent(o, { bubbles: !0, cancelable: !0 })),
|
|
|
+ (g.to = a || n),
|
|
|
+ (g.from = l || n),
|
|
|
+ (g.item = i || n),
|
|
|
+ (g.clone = r),
|
|
|
+ (g.oldIndex = s),
|
|
|
+ (g.newIndex = c),
|
|
|
+ (g.oldDraggableIndex = u),
|
|
|
+ (g.newDraggableIndex = d),
|
|
|
+ (g.originalEvent = h),
|
|
|
+ (g.pullMode = f ? f.lastPutMode : void 0);
|
|
|
+ var b = I({}, p, O.getEventProperties(o, e));
|
|
|
+ for (var y in b) g[y] = b[y];
|
|
|
+ n && n.dispatchEvent(g), v[m] && v[m].call(e, g);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function K(t, e, n) {
|
|
|
+ var o = 2 < arguments.length && void 0 !== n ? n : {},
|
|
|
+ i = o.evt,
|
|
|
+ r = l(o, ["evt"]);
|
|
|
+ O.pluginEvent.bind(Rt)(
|
|
|
+ t,
|
|
|
+ e,
|
|
|
+ I(
|
|
|
+ {
|
|
|
+ dragEl: z,
|
|
|
+ parentEl: G,
|
|
|
+ ghostEl: U,
|
|
|
+ rootEl: q,
|
|
|
+ nextEl: V,
|
|
|
+ lastDownEl: Z,
|
|
|
+ cloneEl: Q,
|
|
|
+ cloneHidden: $,
|
|
|
+ dragStarted: dt,
|
|
|
+ putSortable: it,
|
|
|
+ activeSortable: Rt.active,
|
|
|
+ originalEvent: i,
|
|
|
+ oldIndex: J,
|
|
|
+ oldDraggableIndex: et,
|
|
|
+ newIndex: tt,
|
|
|
+ newDraggableIndex: nt,
|
|
|
+ hideGhostForTarget: At,
|
|
|
+ unhideGhostForTarget: It,
|
|
|
+ cloneNowHidden: function () {
|
|
|
+ $ = !0;
|
|
|
+ },
|
|
|
+ cloneNowShown: function () {
|
|
|
+ $ = !1;
|
|
|
+ },
|
|
|
+ dispatchSortableEvent: function (t) {
|
|
|
+ W({ sortable: e, name: t, originalEvent: i });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ r
|
|
|
+ )
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function W(t) {
|
|
|
+ N(
|
|
|
+ I(
|
|
|
+ {
|
|
|
+ putSortable: it,
|
|
|
+ cloneEl: Q,
|
|
|
+ targetEl: z,
|
|
|
+ rootEl: q,
|
|
|
+ oldIndex: J,
|
|
|
+ oldDraggableIndex: et,
|
|
|
+ newIndex: tt,
|
|
|
+ newDraggableIndex: nt
|
|
|
+ },
|
|
|
+ t
|
|
|
+ )
|
|
|
+ );
|
|
|
+ }
|
|
|
+ var z,
|
|
|
+ G,
|
|
|
+ U,
|
|
|
+ q,
|
|
|
+ V,
|
|
|
+ Z,
|
|
|
+ Q,
|
|
|
+ $,
|
|
|
+ J,
|
|
|
+ tt,
|
|
|
+ et,
|
|
|
+ nt,
|
|
|
+ ot,
|
|
|
+ it,
|
|
|
+ rt,
|
|
|
+ at,
|
|
|
+ lt,
|
|
|
+ st,
|
|
|
+ ct,
|
|
|
+ ut,
|
|
|
+ dt,
|
|
|
+ ht,
|
|
|
+ ft,
|
|
|
+ pt,
|
|
|
+ gt,
|
|
|
+ vt = !1,
|
|
|
+ mt = !1,
|
|
|
+ bt = [],
|
|
|
+ yt = !1,
|
|
|
+ wt = !1,
|
|
|
+ Et = [],
|
|
|
+ Dt = !1,
|
|
|
+ St = [],
|
|
|
+ _t = "undefined" != typeof document,
|
|
|
+ Ct = n,
|
|
|
+ Tt = E || w ? "cssFloat" : "float",
|
|
|
+ xt = _t && !i && !n && "draggable" in document.createElement("div"),
|
|
|
+ Mt = (function () {
|
|
|
+ if (_t) {
|
|
|
+ if (w) return !1;
|
|
|
+ var t = document.createElement("x");
|
|
|
+ return (
|
|
|
+ (t.style.cssText = "pointer-events:auto"),
|
|
|
+ "auto" === t.style.pointerEvents
|
|
|
+ );
|
|
|
+ }
|
|
|
+ })(),
|
|
|
+ Ot = function (t, e) {
|
|
|
+ var n = R(t),
|
|
|
+ o =
|
|
|
+ parseInt(n.width) -
|
|
|
+ parseInt(n.paddingLeft) -
|
|
|
+ parseInt(n.paddingRight) -
|
|
|
+ parseInt(n.borderLeftWidth) -
|
|
|
+ parseInt(n.borderRightWidth),
|
|
|
+ i = m(t, 0, e),
|
|
|
+ r = m(t, 1, e),
|
|
|
+ a = i && R(i),
|
|
|
+ l = r && R(r),
|
|
|
+ s = a && parseInt(a.marginLeft) + parseInt(a.marginRight) + X(i).width,
|
|
|
+ c = l && parseInt(l.marginLeft) + parseInt(l.marginRight) + X(r).width;
|
|
|
+ if ("flex" === n.display)
|
|
|
+ return "column" === n.flexDirection ||
|
|
|
+ "column-reverse" === n.flexDirection
|
|
|
+ ? "vertical"
|
|
|
+ : "horizontal";
|
|
|
+ if ("grid" === n.display)
|
|
|
+ return n.gridTemplateColumns.split(" ").length <= 1
|
|
|
+ ? "vertical"
|
|
|
+ : "horizontal";
|
|
|
+ if (i && a.float && "none" !== a.float) {
|
|
|
+ var u = "left" === a.float ? "left" : "right";
|
|
|
+ return !r || ("both" !== l.clear && l.clear !== u)
|
|
|
+ ? "horizontal"
|
|
|
+ : "vertical";
|
|
|
+ }
|
|
|
+ return i &&
|
|
|
+ ("block" === a.display ||
|
|
|
+ "flex" === a.display ||
|
|
|
+ "table" === a.display ||
|
|
|
+ "grid" === a.display ||
|
|
|
+ (o <= s && "none" === n[Tt]) ||
|
|
|
+ (r && "none" === n[Tt] && o < s + c))
|
|
|
+ ? "vertical"
|
|
|
+ : "horizontal";
|
|
|
+ },
|
|
|
+ Nt = function (t) {
|
|
|
+ function s(a, l) {
|
|
|
+ return function (t, e, n, o) {
|
|
|
+ var i =
|
|
|
+ t.options.group.name &&
|
|
|
+ e.options.group.name &&
|
|
|
+ t.options.group.name === e.options.group.name;
|
|
|
+ if (null == a && (l || i)) return !0;
|
|
|
+ if (null == a || !1 === a) return !1;
|
|
|
+ if (l && "clone" === a) return a;
|
|
|
+ if ("function" == typeof a) return s(a(t, e, n, o), l)(t, e, n, o);
|
|
|
+ var r = (l ? t : e).options.group.name;
|
|
|
+ return (
|
|
|
+ !0 === a ||
|
|
|
+ ("string" == typeof a && a === r) ||
|
|
|
+ (a.join && -1 < a.indexOf(r))
|
|
|
+ );
|
|
|
+ };
|
|
|
+ }
|
|
|
+ var e = {},
|
|
|
+ n = t.group;
|
|
|
+ (n && "object" == o(n)) || (n = { name: n }),
|
|
|
+ (e.name = n.name),
|
|
|
+ (e.checkPull = s(n.pull, !0)),
|
|
|
+ (e.checkPut = s(n.put)),
|
|
|
+ (e.revertClone = n.revertClone),
|
|
|
+ (t.group = e);
|
|
|
+ },
|
|
|
+ At = function () {
|
|
|
+ !Mt && U && R(U, "display", "none");
|
|
|
+ },
|
|
|
+ It = function () {
|
|
|
+ !Mt && U && R(U, "display", "");
|
|
|
+ };
|
|
|
+ _t &&
|
|
|
+ document.addEventListener(
|
|
|
+ "click",
|
|
|
+ function (t) {
|
|
|
+ if (mt)
|
|
|
+ return (
|
|
|
+ t.preventDefault(),
|
|
|
+ t.stopPropagation && t.stopPropagation(),
|
|
|
+ t.stopImmediatePropagation && t.stopImmediatePropagation(),
|
|
|
+ (mt = !1)
|
|
|
+ );
|
|
|
+ },
|
|
|
+ !0
|
|
|
+ );
|
|
|
+ function Pt(t) {
|
|
|
+ if (z) {
|
|
|
+ var e = (function (r, a) {
|
|
|
+ var l;
|
|
|
+ return (
|
|
|
+ bt.some(function (t) {
|
|
|
+ if (!B(t)) {
|
|
|
+ var e = X(t),
|
|
|
+ n = t[j].options.emptyInsertThreshold,
|
|
|
+ o = r >= e.left - n && r <= e.right + n,
|
|
|
+ i = a >= e.top - n && a <= e.bottom + n;
|
|
|
+ return n && o && i ? (l = t) : void 0;
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ l
|
|
|
+ );
|
|
|
+ })((t = t.touches ? t.touches[0] : t).clientX, t.clientY);
|
|
|
+ if (e) {
|
|
|
+ var n = {};
|
|
|
+ for (var o in t) t.hasOwnProperty(o) && (n[o] = t[o]);
|
|
|
+ (n.target = n.rootEl = e),
|
|
|
+ (n.preventDefault = void 0),
|
|
|
+ (n.stopPropagation = void 0),
|
|
|
+ e[j]._onDragOver(n);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function kt(t) {
|
|
|
+ z && z.parentNode[j]._isOutsideThisEl(t.target);
|
|
|
+ }
|
|
|
+ function Rt(t, e) {
|
|
|
+ if (!t || !t.nodeType || 1 !== t.nodeType)
|
|
|
+ throw "Sortable: `el` must be an HTMLElement, not ".concat(
|
|
|
+ {}.toString.call(t)
|
|
|
+ );
|
|
|
+ (this.el = t), (this.options = e = a({}, e)), (t[j] = this);
|
|
|
+ var n = {
|
|
|
+ group: null,
|
|
|
+ sort: !0,
|
|
|
+ disabled: !1,
|
|
|
+ store: null,
|
|
|
+ handle: null,
|
|
|
+ draggable: /^[uo]l$/i.test(t.nodeName) ? ">li" : ">*",
|
|
|
+ swapThreshold: 1,
|
|
|
+ invertSwap: !1,
|
|
|
+ invertedSwapThreshold: null,
|
|
|
+ removeCloneOnHide: !0,
|
|
|
+ direction: function () {
|
|
|
+ return Ot(t, this.options);
|
|
|
+ },
|
|
|
+ ghostClass: "sortable-ghost",
|
|
|
+ chosenClass: "sortable-chosen",
|
|
|
+ dragClass: "sortable-drag",
|
|
|
+ ignore: "a, img",
|
|
|
+ filter: null,
|
|
|
+ preventOnFilter: !0,
|
|
|
+ animation: 0,
|
|
|
+ easing: null,
|
|
|
+ setData: function (t, e) {
|
|
|
+ t.setData("Text", e.textContent);
|
|
|
+ },
|
|
|
+ dropBubble: !1,
|
|
|
+ dragoverBubble: !1,
|
|
|
+ dataIdAttr: "data-id",
|
|
|
+ delay: 0,
|
|
|
+ delayOnTouchOnly: !1,
|
|
|
+ touchStartThreshold:
|
|
|
+ (Number.parseInt ? Number : window).parseInt(
|
|
|
+ window.devicePixelRatio,
|
|
|
+ 10
|
|
|
+ ) || 1,
|
|
|
+ forceFallback: !1,
|
|
|
+ fallbackClass: "sortable-fallback",
|
|
|
+ fallbackOnBody: !1,
|
|
|
+ fallbackTolerance: 0,
|
|
|
+ fallbackOffset: { x: 0, y: 0 },
|
|
|
+ supportPointer:
|
|
|
+ !1 !== Rt.supportPointer && "PointerEvent" in window && !u,
|
|
|
+ emptyInsertThreshold: 5
|
|
|
+ };
|
|
|
+ for (var o in (O.initializePlugins(this, t, n), n)) o in e || (e[o] = n[o]);
|
|
|
+ for (var i in (Nt(e), this))
|
|
|
+ "_" === i.charAt(0) &&
|
|
|
+ "function" == typeof this[i] &&
|
|
|
+ (this[i] = this[i].bind(this));
|
|
|
+ (this.nativeDraggable = !e.forceFallback && xt),
|
|
|
+ this.nativeDraggable && (this.options.touchStartThreshold = 1),
|
|
|
+ e.supportPointer
|
|
|
+ ? d(t, "pointerdown", this._onTapStart)
|
|
|
+ : (d(t, "mousedown", this._onTapStart),
|
|
|
+ d(t, "touchstart", this._onTapStart)),
|
|
|
+ this.nativeDraggable && (d(t, "dragover", this), d(t, "dragenter", this)),
|
|
|
+ bt.push(this.el),
|
|
|
+ e.store && e.store.get && this.sort(e.store.get(this) || []),
|
|
|
+ a(this, T());
|
|
|
+ }
|
|
|
+ function Xt(t, e, n, o, i, r, a, l) {
|
|
|
+ var s,
|
|
|
+ c,
|
|
|
+ u = t[j],
|
|
|
+ d = u.options.onMove;
|
|
|
+ return (
|
|
|
+ !window.CustomEvent || w || E
|
|
|
+ ? (s = document.createEvent("Event")).initEvent("move", !0, !0)
|
|
|
+ : (s = new CustomEvent("move", { bubbles: !0, cancelable: !0 })),
|
|
|
+ (s.to = e),
|
|
|
+ (s.from = t),
|
|
|
+ (s.dragged = n),
|
|
|
+ (s.draggedRect = o),
|
|
|
+ (s.related = i || e),
|
|
|
+ (s.relatedRect = r || X(e)),
|
|
|
+ (s.willInsertAfter = l),
|
|
|
+ (s.originalEvent = a),
|
|
|
+ t.dispatchEvent(s),
|
|
|
+ d && (c = d.call(u, s, a)),
|
|
|
+ c
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function Yt(t) {
|
|
|
+ t.draggable = !1;
|
|
|
+ }
|
|
|
+ function Bt() {
|
|
|
+ Dt = !1;
|
|
|
+ }
|
|
|
+ function Ft(t) {
|
|
|
+ for (
|
|
|
+ var e = t.tagName + t.className + t.src + t.href + t.textContent,
|
|
|
+ n = e.length,
|
|
|
+ o = 0;
|
|
|
+ n--;
|
|
|
+
|
|
|
+ )
|
|
|
+ o += e.charCodeAt(n);
|
|
|
+ return o.toString(36);
|
|
|
+ }
|
|
|
+ function Ht(t) {
|
|
|
+ return setTimeout(t, 0);
|
|
|
+ }
|
|
|
+ function Lt(t) {
|
|
|
+ return clearTimeout(t);
|
|
|
+ }
|
|
|
+ (Rt.prototype = {
|
|
|
+ constructor: Rt,
|
|
|
+ _isOutsideThisEl: function (t) {
|
|
|
+ this.el.contains(t) || t === this.el || (ht = null);
|
|
|
+ },
|
|
|
+ _getDirection: function (t, e) {
|
|
|
+ return "function" == typeof this.options.direction
|
|
|
+ ? this.options.direction.call(this, t, e, z)
|
|
|
+ : this.options.direction;
|
|
|
+ },
|
|
|
+ _onTapStart: function (e) {
|
|
|
+ if (e.cancelable) {
|
|
|
+ var n = this,
|
|
|
+ o = this.el,
|
|
|
+ t = this.options,
|
|
|
+ i = t.preventOnFilter,
|
|
|
+ r = e.type,
|
|
|
+ a =
|
|
|
+ (e.touches && e.touches[0]) ||
|
|
|
+ (e.pointerType && "touch" === e.pointerType && e),
|
|
|
+ l = (a || e).target,
|
|
|
+ s =
|
|
|
+ (e.target.shadowRoot &&
|
|
|
+ ((e.path && e.path[0]) ||
|
|
|
+ (e.composedPath && e.composedPath()[0]))) ||
|
|
|
+ l,
|
|
|
+ c = t.filter;
|
|
|
+ if (
|
|
|
+ ((function (t) {
|
|
|
+ St.length = 0;
|
|
|
+ var e = t.getElementsByTagName("input"),
|
|
|
+ n = e.length;
|
|
|
+ for (; n--; ) {
|
|
|
+ var o = e[n];
|
|
|
+ o.checked && St.push(o);
|
|
|
+ }
|
|
|
+ })(o),
|
|
|
+ !z &&
|
|
|
+ !(
|
|
|
+ (/mousedown|pointerdown/.test(r) && 0 !== e.button) ||
|
|
|
+ t.disabled
|
|
|
+ ) &&
|
|
|
+ !s.isContentEditable &&
|
|
|
+ (this.nativeDraggable ||
|
|
|
+ !u ||
|
|
|
+ !l ||
|
|
|
+ "SELECT" !== l.tagName.toUpperCase()) &&
|
|
|
+ !(((l = P(l, t.draggable, o, !1)) && l.animated) || Z === l))
|
|
|
+ ) {
|
|
|
+ if (((J = F(l)), (et = F(l, t.draggable)), "function" == typeof c)) {
|
|
|
+ if (c.call(this, e, l, this))
|
|
|
+ return (
|
|
|
+ W({
|
|
|
+ sortable: n,
|
|
|
+ rootEl: s,
|
|
|
+ name: "filter",
|
|
|
+ targetEl: l,
|
|
|
+ toEl: o,
|
|
|
+ fromEl: o
|
|
|
+ }),
|
|
|
+ K("filter", n, { evt: e }),
|
|
|
+ void (i && e.cancelable && e.preventDefault())
|
|
|
+ );
|
|
|
+ } else if (
|
|
|
+ c &&
|
|
|
+ (c = c.split(",").some(function (t) {
|
|
|
+ if ((t = P(s, t.trim(), o, !1)))
|
|
|
+ return (
|
|
|
+ W({
|
|
|
+ sortable: n,
|
|
|
+ rootEl: t,
|
|
|
+ name: "filter",
|
|
|
+ targetEl: l,
|
|
|
+ fromEl: o,
|
|
|
+ toEl: o
|
|
|
+ }),
|
|
|
+ K("filter", n, { evt: e }),
|
|
|
+ !0
|
|
|
+ );
|
|
|
+ }))
|
|
|
+ )
|
|
|
+ return void (i && e.cancelable && e.preventDefault());
|
|
|
+ (t.handle && !P(s, t.handle, o, !1)) ||
|
|
|
+ this._prepareDragStart(e, a, l);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _prepareDragStart: function (t, e, n) {
|
|
|
+ var o,
|
|
|
+ i = this,
|
|
|
+ r = i.el,
|
|
|
+ a = i.options,
|
|
|
+ l = r.ownerDocument;
|
|
|
+ if (n && !z && n.parentNode === r) {
|
|
|
+ var s = X(n);
|
|
|
+ if (
|
|
|
+ ((q = r),
|
|
|
+ (G = (z = n).parentNode),
|
|
|
+ (V = z.nextSibling),
|
|
|
+ (Z = n),
|
|
|
+ (ot = a.group),
|
|
|
+ (rt = {
|
|
|
+ target: (Rt.dragged = z),
|
|
|
+ clientX: (e || t).clientX,
|
|
|
+ clientY: (e || t).clientY
|
|
|
+ }),
|
|
|
+ (ct = rt.clientX - s.left),
|
|
|
+ (ut = rt.clientY - s.top),
|
|
|
+ (this._lastX = (e || t).clientX),
|
|
|
+ (this._lastY = (e || t).clientY),
|
|
|
+ (z.style["will-change"] = "all"),
|
|
|
+ (o = function () {
|
|
|
+ K("delayEnded", i, { evt: t }),
|
|
|
+ Rt.eventCanceled
|
|
|
+ ? i._onDrop()
|
|
|
+ : (i._disableDelayedDragEvents(),
|
|
|
+ !c && i.nativeDraggable && (z.draggable = !0),
|
|
|
+ i._triggerDragStart(t, e),
|
|
|
+ W({ sortable: i, name: "choose", originalEvent: t }),
|
|
|
+ k(z, a.chosenClass, !0));
|
|
|
+ }),
|
|
|
+ a.ignore.split(",").forEach(function (t) {
|
|
|
+ g(z, t.trim(), Yt);
|
|
|
+ }),
|
|
|
+ d(l, "dragover", Pt),
|
|
|
+ d(l, "mousemove", Pt),
|
|
|
+ d(l, "touchmove", Pt),
|
|
|
+ d(l, "mouseup", i._onDrop),
|
|
|
+ d(l, "touchend", i._onDrop),
|
|
|
+ d(l, "touchcancel", i._onDrop),
|
|
|
+ c &&
|
|
|
+ this.nativeDraggable &&
|
|
|
+ ((this.options.touchStartThreshold = 4), (z.draggable = !0)),
|
|
|
+ K("delayStart", this, { evt: t }),
|
|
|
+ !a.delay ||
|
|
|
+ (a.delayOnTouchOnly && !e) ||
|
|
|
+ (this.nativeDraggable && (E || w)))
|
|
|
+ )
|
|
|
+ o();
|
|
|
+ else {
|
|
|
+ if (Rt.eventCanceled) return void this._onDrop();
|
|
|
+ d(l, "mouseup", i._disableDelayedDrag),
|
|
|
+ d(l, "touchend", i._disableDelayedDrag),
|
|
|
+ d(l, "touchcancel", i._disableDelayedDrag),
|
|
|
+ d(l, "mousemove", i._delayedDragTouchMoveHandler),
|
|
|
+ d(l, "touchmove", i._delayedDragTouchMoveHandler),
|
|
|
+ a.supportPointer &&
|
|
|
+ d(l, "pointermove", i._delayedDragTouchMoveHandler),
|
|
|
+ (i._dragStartTimer = setTimeout(o, a.delay));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _delayedDragTouchMoveHandler: function (t) {
|
|
|
+ var e = t.touches ? t.touches[0] : t;
|
|
|
+ Math.max(
|
|
|
+ Math.abs(e.clientX - this._lastX),
|
|
|
+ Math.abs(e.clientY - this._lastY)
|
|
|
+ ) >=
|
|
|
+ Math.floor(
|
|
|
+ this.options.touchStartThreshold /
|
|
|
+ ((this.nativeDraggable && window.devicePixelRatio) || 1)
|
|
|
+ ) && this._disableDelayedDrag();
|
|
|
+ },
|
|
|
+ _disableDelayedDrag: function () {
|
|
|
+ z && Yt(z),
|
|
|
+ clearTimeout(this._dragStartTimer),
|
|
|
+ this._disableDelayedDragEvents();
|
|
|
+ },
|
|
|
+ _disableDelayedDragEvents: function () {
|
|
|
+ var t = this.el.ownerDocument;
|
|
|
+ s(t, "mouseup", this._disableDelayedDrag),
|
|
|
+ s(t, "touchend", this._disableDelayedDrag),
|
|
|
+ s(t, "touchcancel", this._disableDelayedDrag),
|
|
|
+ s(t, "mousemove", this._delayedDragTouchMoveHandler),
|
|
|
+ s(t, "touchmove", this._delayedDragTouchMoveHandler),
|
|
|
+ s(t, "pointermove", this._delayedDragTouchMoveHandler);
|
|
|
+ },
|
|
|
+ _triggerDragStart: function (t, e) {
|
|
|
+ (e = e || ("touch" == t.pointerType && t)),
|
|
|
+ !this.nativeDraggable || e
|
|
|
+ ? this.options.supportPointer
|
|
|
+ ? d(document, "pointermove", this._onTouchMove)
|
|
|
+ : d(document, e ? "touchmove" : "mousemove", this._onTouchMove)
|
|
|
+ : (d(z, "dragend", this), d(q, "dragstart", this._onDragStart));
|
|
|
+ try {
|
|
|
+ document.selection
|
|
|
+ ? Ht(function () {
|
|
|
+ document.selection.empty();
|
|
|
+ })
|
|
|
+ : window.getSelection().removeAllRanges();
|
|
|
+ } catch (t) {}
|
|
|
+ },
|
|
|
+ _dragStarted: function (t, e) {
|
|
|
+ if (((vt = !1), q && z)) {
|
|
|
+ K("dragStarted", this, { evt: e }),
|
|
|
+ this.nativeDraggable && d(document, "dragover", kt);
|
|
|
+ var n = this.options;
|
|
|
+ t || k(z, n.dragClass, !1),
|
|
|
+ k(z, n.ghostClass, !0),
|
|
|
+ (Rt.active = this),
|
|
|
+ t && this._appendGhost(),
|
|
|
+ W({ sortable: this, name: "start", originalEvent: e });
|
|
|
+ } else this._nulling();
|
|
|
+ },
|
|
|
+ _emulateDragOver: function () {
|
|
|
+ if (at) {
|
|
|
+ (this._lastX = at.clientX), (this._lastY = at.clientY), At();
|
|
|
+ for (
|
|
|
+ var t = document.elementFromPoint(at.clientX, at.clientY), e = t;
|
|
|
+ t &&
|
|
|
+ t.shadowRoot &&
|
|
|
+ (t = t.shadowRoot.elementFromPoint(at.clientX, at.clientY)) !== e;
|
|
|
+
|
|
|
+ )
|
|
|
+ e = t;
|
|
|
+ if ((z.parentNode[j]._isOutsideThisEl(t), e))
|
|
|
+ do {
|
|
|
+ if (e[j]) {
|
|
|
+ if (
|
|
|
+ e[j]._onDragOver({
|
|
|
+ clientX: at.clientX,
|
|
|
+ clientY: at.clientY,
|
|
|
+ target: t,
|
|
|
+ rootEl: e
|
|
|
+ }) &&
|
|
|
+ !this.options.dragoverBubble
|
|
|
+ )
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ t = e;
|
|
|
+ } while ((e = e.parentNode));
|
|
|
+ It();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _onTouchMove: function (t) {
|
|
|
+ if (rt) {
|
|
|
+ var e = this.options,
|
|
|
+ n = e.fallbackTolerance,
|
|
|
+ o = e.fallbackOffset,
|
|
|
+ i = t.touches ? t.touches[0] : t,
|
|
|
+ r = U && v(U, !0),
|
|
|
+ a = U && r && r.a,
|
|
|
+ l = U && r && r.d,
|
|
|
+ s = Ct && gt && b(gt),
|
|
|
+ c =
|
|
|
+ (i.clientX - rt.clientX + o.x) / (a || 1) +
|
|
|
+ (s ? s[0] - Et[0] : 0) / (a || 1),
|
|
|
+ u =
|
|
|
+ (i.clientY - rt.clientY + o.y) / (l || 1) +
|
|
|
+ (s ? s[1] - Et[1] : 0) / (l || 1);
|
|
|
+ if (!Rt.active && !vt) {
|
|
|
+ if (
|
|
|
+ n &&
|
|
|
+ Math.max(
|
|
|
+ Math.abs(i.clientX - this._lastX),
|
|
|
+ Math.abs(i.clientY - this._lastY)
|
|
|
+ ) < n
|
|
|
+ )
|
|
|
+ return;
|
|
|
+ this._onDragStart(t, !0);
|
|
|
+ }
|
|
|
+ if (U) {
|
|
|
+ r
|
|
|
+ ? ((r.e += c - (lt || 0)), (r.f += u - (st || 0)))
|
|
|
+ : (r = { a: 1, b: 0, c: 0, d: 1, e: c, f: u });
|
|
|
+ var d = "matrix("
|
|
|
+ .concat(r.a, ",")
|
|
|
+ .concat(r.b, ",")
|
|
|
+ .concat(r.c, ",")
|
|
|
+ .concat(r.d, ",")
|
|
|
+ .concat(r.e, ",")
|
|
|
+ .concat(r.f, ")");
|
|
|
+ R(U, "webkitTransform", d),
|
|
|
+ R(U, "mozTransform", d),
|
|
|
+ R(U, "msTransform", d),
|
|
|
+ R(U, "transform", d),
|
|
|
+ (lt = c),
|
|
|
+ (st = u),
|
|
|
+ (at = i);
|
|
|
+ }
|
|
|
+ t.cancelable && t.preventDefault();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _appendGhost: function () {
|
|
|
+ if (!U) {
|
|
|
+ var t = this.options.fallbackOnBody ? document.body : q,
|
|
|
+ e = X(z, !0, Ct, !0, t),
|
|
|
+ n = this.options;
|
|
|
+ if (Ct) {
|
|
|
+ for (
|
|
|
+ gt = t;
|
|
|
+ "static" === R(gt, "position") &&
|
|
|
+ "none" === R(gt, "transform") &&
|
|
|
+ gt !== document;
|
|
|
+
|
|
|
+ )
|
|
|
+ gt = gt.parentNode;
|
|
|
+ gt !== document.body && gt !== document.documentElement
|
|
|
+ ? (gt === document && (gt = A()),
|
|
|
+ (e.top += gt.scrollTop),
|
|
|
+ (e.left += gt.scrollLeft))
|
|
|
+ : (gt = A()),
|
|
|
+ (Et = b(gt));
|
|
|
+ }
|
|
|
+ k((U = z.cloneNode(!0)), n.ghostClass, !1),
|
|
|
+ k(U, n.fallbackClass, !0),
|
|
|
+ k(U, n.dragClass, !0),
|
|
|
+ R(U, "transition", ""),
|
|
|
+ R(U, "transform", ""),
|
|
|
+ R(U, "box-sizing", "border-box"),
|
|
|
+ R(U, "margin", 0),
|
|
|
+ R(U, "top", e.top),
|
|
|
+ R(U, "left", e.left),
|
|
|
+ R(U, "width", e.width),
|
|
|
+ R(U, "height", e.height),
|
|
|
+ R(U, "opacity", "0.8"),
|
|
|
+ R(U, "position", Ct ? "absolute" : "fixed"),
|
|
|
+ R(U, "zIndex", "100000"),
|
|
|
+ R(U, "pointerEvents", "none"),
|
|
|
+ (Rt.ghost = U),
|
|
|
+ t.appendChild(U),
|
|
|
+ R(
|
|
|
+ U,
|
|
|
+ "transform-origin",
|
|
|
+ (ct / parseInt(U.style.width)) * 100 +
|
|
|
+ "% " +
|
|
|
+ (ut / parseInt(U.style.height)) * 100 +
|
|
|
+ "%"
|
|
|
+ );
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _onDragStart: function (t, e) {
|
|
|
+ var n = this,
|
|
|
+ o = t.dataTransfer,
|
|
|
+ i = n.options;
|
|
|
+ K("dragStart", this, { evt: t }),
|
|
|
+ Rt.eventCanceled
|
|
|
+ ? this._onDrop()
|
|
|
+ : (K("setupClone", this),
|
|
|
+ Rt.eventCanceled ||
|
|
|
+ (((Q = S(z)).draggable = !1),
|
|
|
+ (Q.style["will-change"] = ""),
|
|
|
+ this._hideClone(),
|
|
|
+ k(Q, this.options.chosenClass, !1),
|
|
|
+ (Rt.clone = Q)),
|
|
|
+ (n.cloneId = Ht(function () {
|
|
|
+ K("clone", n),
|
|
|
+ Rt.eventCanceled ||
|
|
|
+ (n.options.removeCloneOnHide || q.insertBefore(Q, z),
|
|
|
+ n._hideClone(),
|
|
|
+ W({ sortable: n, name: "clone" }));
|
|
|
+ })),
|
|
|
+ e || k(z, i.dragClass, !0),
|
|
|
+ e
|
|
|
+ ? ((mt = !0), (n._loopId = setInterval(n._emulateDragOver, 50)))
|
|
|
+ : (s(document, "mouseup", n._onDrop),
|
|
|
+ s(document, "touchend", n._onDrop),
|
|
|
+ s(document, "touchcancel", n._onDrop),
|
|
|
+ o &&
|
|
|
+ ((o.effectAllowed = "move"),
|
|
|
+ i.setData && i.setData.call(n, o, z)),
|
|
|
+ d(document, "drop", n),
|
|
|
+ R(z, "transform", "translateZ(0)")),
|
|
|
+ (vt = !0),
|
|
|
+ (n._dragStartId = Ht(n._dragStarted.bind(n, e, t))),
|
|
|
+ d(document, "selectstart", n),
|
|
|
+ (dt = !0),
|
|
|
+ u && R(document.body, "user-select", "none"));
|
|
|
+ },
|
|
|
+ _onDragOver: function (n) {
|
|
|
+ var o,
|
|
|
+ i,
|
|
|
+ r,
|
|
|
+ a,
|
|
|
+ l = this.el,
|
|
|
+ s = n.target,
|
|
|
+ e = this.options,
|
|
|
+ t = e.group,
|
|
|
+ c = Rt.active,
|
|
|
+ u = ot === t,
|
|
|
+ d = e.sort,
|
|
|
+ h = it || c,
|
|
|
+ f = this,
|
|
|
+ p = !1;
|
|
|
+ if (!Dt) {
|
|
|
+ if (
|
|
|
+ (void 0 !== n.preventDefault && n.cancelable && n.preventDefault(),
|
|
|
+ (s = P(s, e.draggable, l, !0)),
|
|
|
+ M("dragOver"),
|
|
|
+ Rt.eventCanceled)
|
|
|
+ )
|
|
|
+ return p;
|
|
|
+ if (
|
|
|
+ z.contains(n.target) ||
|
|
|
+ (s.animated && s.animatingX && s.animatingY) ||
|
|
|
+ f._ignoreWhileAnimating === s
|
|
|
+ )
|
|
|
+ return N(!1);
|
|
|
+ if (
|
|
|
+ ((mt = !1),
|
|
|
+ c &&
|
|
|
+ !e.disabled &&
|
|
|
+ (u
|
|
|
+ ? d || (r = !q.contains(z))
|
|
|
+ : it === this ||
|
|
|
+ ((this.lastPutMode = ot.checkPull(this, c, z, n)) &&
|
|
|
+ t.checkPut(this, c, z, n))))
|
|
|
+ ) {
|
|
|
+ if (
|
|
|
+ ((a = "vertical" === this._getDirection(n, s)),
|
|
|
+ (o = X(z)),
|
|
|
+ M("dragOverValid"),
|
|
|
+ Rt.eventCanceled)
|
|
|
+ )
|
|
|
+ return p;
|
|
|
+ if (r)
|
|
|
+ return (
|
|
|
+ (G = q),
|
|
|
+ O(),
|
|
|
+ this._hideClone(),
|
|
|
+ M("revert"),
|
|
|
+ Rt.eventCanceled || (V ? q.insertBefore(z, V) : q.appendChild(z)),
|
|
|
+ N(!0)
|
|
|
+ );
|
|
|
+ var g = B(l, e.draggable);
|
|
|
+ if (
|
|
|
+ !g ||
|
|
|
+ ((function (t, e, n) {
|
|
|
+ var o = X(B(n.el, n.options.draggable));
|
|
|
+ return e
|
|
|
+ ? t.clientX > o.right + 10 ||
|
|
|
+ (t.clientX <= o.right &&
|
|
|
+ t.clientY > o.bottom &&
|
|
|
+ t.clientX >= o.left)
|
|
|
+ : (t.clientX > o.right && t.clientY > o.top) ||
|
|
|
+ (t.clientX <= o.right && t.clientY > o.bottom + 10);
|
|
|
+ })(n, a, this) &&
|
|
|
+ !g.animated)
|
|
|
+ ) {
|
|
|
+ if (g === z) return N(!1);
|
|
|
+ if (
|
|
|
+ (g && l === n.target && (s = g),
|
|
|
+ s && (i = X(s)),
|
|
|
+ !1 !== Xt(q, l, z, o, s, i, n, !!s))
|
|
|
+ )
|
|
|
+ return O(), l.appendChild(z), (G = l), A(), N(!0);
|
|
|
+ } else if (s.parentNode === l) {
|
|
|
+ i = X(s);
|
|
|
+ var v,
|
|
|
+ m,
|
|
|
+ b,
|
|
|
+ y = z.parentNode !== l,
|
|
|
+ w = !(function (t, e, n) {
|
|
|
+ var o = n ? t.left : t.top,
|
|
|
+ i = n ? t.right : t.bottom,
|
|
|
+ r = n ? t.width : t.height,
|
|
|
+ a = n ? e.left : e.top,
|
|
|
+ l = n ? e.right : e.bottom,
|
|
|
+ s = n ? e.width : e.height;
|
|
|
+ return o === a || i === l || o + r / 2 === a + s / 2;
|
|
|
+ })(
|
|
|
+ (z.animated && z.toRect) || o,
|
|
|
+ (s.animated && s.toRect) || i,
|
|
|
+ a
|
|
|
+ ),
|
|
|
+ E = a ? "top" : "left",
|
|
|
+ D = Y(s, "top", "top") || Y(z, "top", "top"),
|
|
|
+ S = D ? D.scrollTop : void 0;
|
|
|
+ if (
|
|
|
+ (ht !== s &&
|
|
|
+ ((m = i[E]), (yt = !1), (wt = (!w && e.invertSwap) || y)),
|
|
|
+ 0 !==
|
|
|
+ (v = (function (t, e, n, o, i, r, a, l) {
|
|
|
+ var s = o ? t.clientY : t.clientX,
|
|
|
+ c = o ? n.height : n.width,
|
|
|
+ u = o ? n.top : n.left,
|
|
|
+ d = o ? n.bottom : n.right,
|
|
|
+ h = !1;
|
|
|
+ if (!a)
|
|
|
+ if (l && pt < c * i) {
|
|
|
+ if (
|
|
|
+ (!yt &&
|
|
|
+ (1 === ft
|
|
|
+ ? u + (c * r) / 2 < s
|
|
|
+ : s < d - (c * r) / 2) &&
|
|
|
+ (yt = !0),
|
|
|
+ yt)
|
|
|
+ )
|
|
|
+ h = !0;
|
|
|
+ else if (1 === ft ? s < u + pt : d - pt < s) return -ft;
|
|
|
+ } else if (
|
|
|
+ u + (c * (1 - i)) / 2 < s &&
|
|
|
+ s < d - (c * (1 - i)) / 2
|
|
|
+ )
|
|
|
+ return (function (t) {
|
|
|
+ return F(z) < F(t) ? 1 : -1;
|
|
|
+ })(e);
|
|
|
+ if (
|
|
|
+ (h = h || a) &&
|
|
|
+ (s < u + (c * r) / 2 || d - (c * r) / 2 < s)
|
|
|
+ )
|
|
|
+ return u + c / 2 < s ? 1 : -1;
|
|
|
+ return 0;
|
|
|
+ })(
|
|
|
+ n,
|
|
|
+ s,
|
|
|
+ i,
|
|
|
+ a,
|
|
|
+ w ? 1 : e.swapThreshold,
|
|
|
+ null == e.invertedSwapThreshold
|
|
|
+ ? e.swapThreshold
|
|
|
+ : e.invertedSwapThreshold,
|
|
|
+ wt,
|
|
|
+ ht === s
|
|
|
+ )))
|
|
|
+ )
|
|
|
+ for (
|
|
|
+ var _ = F(z);
|
|
|
+ (_ -= v),
|
|
|
+ (b = G.children[_]) &&
|
|
|
+ ("none" === R(b, "display") || b === U);
|
|
|
+
|
|
|
+ );
|
|
|
+ if (0 === v || b === s) return N(!1);
|
|
|
+ ft = v;
|
|
|
+ var C = (ht = s).nextElementSibling,
|
|
|
+ T = !1,
|
|
|
+ x = Xt(q, l, z, o, s, i, n, (T = 1 === v));
|
|
|
+ if (!1 !== x)
|
|
|
+ return (
|
|
|
+ (1 !== x && -1 !== x) || (T = 1 === x),
|
|
|
+ (Dt = !0),
|
|
|
+ setTimeout(Bt, 30),
|
|
|
+ O(),
|
|
|
+ T && !C
|
|
|
+ ? l.appendChild(z)
|
|
|
+ : s.parentNode.insertBefore(z, T ? C : s),
|
|
|
+ D && L(D, 0, S - D.scrollTop),
|
|
|
+ (G = z.parentNode),
|
|
|
+ void 0 === m || wt || (pt = Math.abs(m - X(s)[E])),
|
|
|
+ A(),
|
|
|
+ N(!0)
|
|
|
+ );
|
|
|
+ }
|
|
|
+ if (l.contains(z)) return N(!1);
|
|
|
+ }
|
|
|
+ return !1;
|
|
|
+ }
|
|
|
+ function M(t, e) {
|
|
|
+ K(
|
|
|
+ t,
|
|
|
+ f,
|
|
|
+ I(
|
|
|
+ {
|
|
|
+ evt: n,
|
|
|
+ isOwner: u,
|
|
|
+ axis: a ? "vertical" : "horizontal",
|
|
|
+ revert: r,
|
|
|
+ dragRect: o,
|
|
|
+ targetRect: i,
|
|
|
+ canSort: d,
|
|
|
+ fromSortable: h,
|
|
|
+ target: s,
|
|
|
+ completed: N,
|
|
|
+ onMove: function (t, e) {
|
|
|
+ return Xt(q, l, z, o, t, X(t), n, e);
|
|
|
+ },
|
|
|
+ changed: A
|
|
|
+ },
|
|
|
+ e
|
|
|
+ )
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function O() {
|
|
|
+ M("dragOverAnimationCapture"),
|
|
|
+ f.captureAnimationState(),
|
|
|
+ f !== h && h.captureAnimationState();
|
|
|
+ }
|
|
|
+ function N(t) {
|
|
|
+ return (
|
|
|
+ M("dragOverCompleted", { insertion: t }),
|
|
|
+ t &&
|
|
|
+ (u ? c._hideClone() : c._showClone(f),
|
|
|
+ f !== h &&
|
|
|
+ (k(z, it ? it.options.ghostClass : c.options.ghostClass, !1),
|
|
|
+ k(z, e.ghostClass, !0)),
|
|
|
+ it !== f && f !== Rt.active
|
|
|
+ ? (it = f)
|
|
|
+ : f === Rt.active && it && (it = null),
|
|
|
+ h === f && (f._ignoreWhileAnimating = s),
|
|
|
+ f.animateAll(function () {
|
|
|
+ M("dragOverAnimationComplete"), (f._ignoreWhileAnimating = null);
|
|
|
+ }),
|
|
|
+ f !== h && (h.animateAll(), (h._ignoreWhileAnimating = null))),
|
|
|
+ ((s === z && !z.animated) || (s === l && !s.animated)) && (ht = null),
|
|
|
+ e.dragoverBubble ||
|
|
|
+ n.rootEl ||
|
|
|
+ s === document ||
|
|
|
+ (z.parentNode[j]._isOutsideThisEl(n.target), t || Pt(n)),
|
|
|
+ !e.dragoverBubble && n.stopPropagation && n.stopPropagation(),
|
|
|
+ (p = !0)
|
|
|
+ );
|
|
|
+ }
|
|
|
+ function A() {
|
|
|
+ (tt = F(z)),
|
|
|
+ (nt = F(z, e.draggable)),
|
|
|
+ W({
|
|
|
+ sortable: f,
|
|
|
+ name: "change",
|
|
|
+ toEl: l,
|
|
|
+ newIndex: tt,
|
|
|
+ newDraggableIndex: nt,
|
|
|
+ originalEvent: n
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _ignoreWhileAnimating: null,
|
|
|
+ _offMoveEvents: function () {
|
|
|
+ s(document, "mousemove", this._onTouchMove),
|
|
|
+ s(document, "touchmove", this._onTouchMove),
|
|
|
+ s(document, "pointermove", this._onTouchMove),
|
|
|
+ s(document, "dragover", Pt),
|
|
|
+ s(document, "mousemove", Pt),
|
|
|
+ s(document, "touchmove", Pt);
|
|
|
+ },
|
|
|
+ _offUpEvents: function () {
|
|
|
+ var t = this.el.ownerDocument;
|
|
|
+ s(t, "mouseup", this._onDrop),
|
|
|
+ s(t, "touchend", this._onDrop),
|
|
|
+ s(t, "pointerup", this._onDrop),
|
|
|
+ s(t, "touchcancel", this._onDrop),
|
|
|
+ s(document, "selectstart", this);
|
|
|
+ },
|
|
|
+ _onDrop: function (t) {
|
|
|
+ var e = this.el,
|
|
|
+ n = this.options;
|
|
|
+ (tt = F(z)),
|
|
|
+ (nt = F(z, n.draggable)),
|
|
|
+ K("drop", this, { evt: t }),
|
|
|
+ (G = z && z.parentNode),
|
|
|
+ (tt = F(z)),
|
|
|
+ (nt = F(z, n.draggable)),
|
|
|
+ Rt.eventCanceled ||
|
|
|
+ ((yt = wt = vt = !1),
|
|
|
+ clearInterval(this._loopId),
|
|
|
+ clearTimeout(this._dragStartTimer),
|
|
|
+ Lt(this.cloneId),
|
|
|
+ Lt(this._dragStartId),
|
|
|
+ this.nativeDraggable &&
|
|
|
+ (s(document, "drop", this), s(e, "dragstart", this._onDragStart)),
|
|
|
+ this._offMoveEvents(),
|
|
|
+ this._offUpEvents(),
|
|
|
+ u && R(document.body, "user-select", ""),
|
|
|
+ R(z, "transform", ""),
|
|
|
+ t &&
|
|
|
+ (dt &&
|
|
|
+ (t.cancelable && t.preventDefault(),
|
|
|
+ n.dropBubble || t.stopPropagation()),
|
|
|
+ U && U.parentNode && U.parentNode.removeChild(U),
|
|
|
+ (q === G || (it && "clone" !== it.lastPutMode)) &&
|
|
|
+ Q &&
|
|
|
+ Q.parentNode &&
|
|
|
+ Q.parentNode.removeChild(Q),
|
|
|
+ z &&
|
|
|
+ (this.nativeDraggable && s(z, "dragend", this),
|
|
|
+ Yt(z),
|
|
|
+ (z.style["will-change"] = ""),
|
|
|
+ dt &&
|
|
|
+ !vt &&
|
|
|
+ k(z, it ? it.options.ghostClass : this.options.ghostClass, !1),
|
|
|
+ k(z, this.options.chosenClass, !1),
|
|
|
+ W({
|
|
|
+ sortable: this,
|
|
|
+ name: "unchoose",
|
|
|
+ toEl: G,
|
|
|
+ newIndex: null,
|
|
|
+ newDraggableIndex: null,
|
|
|
+ originalEvent: t
|
|
|
+ }),
|
|
|
+ q !== G
|
|
|
+ ? (0 <= tt &&
|
|
|
+ (W({
|
|
|
+ rootEl: G,
|
|
|
+ name: "add",
|
|
|
+ toEl: G,
|
|
|
+ fromEl: q,
|
|
|
+ originalEvent: t
|
|
|
+ }),
|
|
|
+ W({
|
|
|
+ sortable: this,
|
|
|
+ name: "remove",
|
|
|
+ toEl: G,
|
|
|
+ originalEvent: t
|
|
|
+ }),
|
|
|
+ W({
|
|
|
+ rootEl: G,
|
|
|
+ name: "sort",
|
|
|
+ toEl: G,
|
|
|
+ fromEl: q,
|
|
|
+ originalEvent: t
|
|
|
+ }),
|
|
|
+ W({
|
|
|
+ sortable: this,
|
|
|
+ name: "sort",
|
|
|
+ toEl: G,
|
|
|
+ originalEvent: t
|
|
|
+ })),
|
|
|
+ it && it.save())
|
|
|
+ : tt !== J &&
|
|
|
+ 0 <= tt &&
|
|
|
+ (W({
|
|
|
+ sortable: this,
|
|
|
+ name: "update",
|
|
|
+ toEl: G,
|
|
|
+ originalEvent: t
|
|
|
+ }),
|
|
|
+ W({
|
|
|
+ sortable: this,
|
|
|
+ name: "sort",
|
|
|
+ toEl: G,
|
|
|
+ originalEvent: t
|
|
|
+ })),
|
|
|
+ Rt.active &&
|
|
|
+ ((null != tt && -1 !== tt) || ((tt = J), (nt = et)),
|
|
|
+ W({ sortable: this, name: "end", toEl: G, originalEvent: t }),
|
|
|
+ this.save())))),
|
|
|
+ this._nulling();
|
|
|
+ },
|
|
|
+ _nulling: function () {
|
|
|
+ K("nulling", this),
|
|
|
+ (q =
|
|
|
+ z =
|
|
|
+ G =
|
|
|
+ U =
|
|
|
+ V =
|
|
|
+ Q =
|
|
|
+ Z =
|
|
|
+ $ =
|
|
|
+ rt =
|
|
|
+ at =
|
|
|
+ dt =
|
|
|
+ tt =
|
|
|
+ nt =
|
|
|
+ J =
|
|
|
+ et =
|
|
|
+ ht =
|
|
|
+ ft =
|
|
|
+ it =
|
|
|
+ ot =
|
|
|
+ Rt.dragged =
|
|
|
+ Rt.ghost =
|
|
|
+ Rt.clone =
|
|
|
+ Rt.active =
|
|
|
+ null),
|
|
|
+ St.forEach(function (t) {
|
|
|
+ t.checked = !0;
|
|
|
+ }),
|
|
|
+ (St.length = lt = st = 0);
|
|
|
+ },
|
|
|
+ handleEvent: function (t) {
|
|
|
+ switch (t.type) {
|
|
|
+ case "drop":
|
|
|
+ case "dragend":
|
|
|
+ this._onDrop(t);
|
|
|
+ break;
|
|
|
+ case "dragenter":
|
|
|
+ case "dragover":
|
|
|
+ z &&
|
|
|
+ (this._onDragOver(t),
|
|
|
+ (function (t) {
|
|
|
+ t.dataTransfer && (t.dataTransfer.dropEffect = "move");
|
|
|
+ t.cancelable && t.preventDefault();
|
|
|
+ })(t));
|
|
|
+ break;
|
|
|
+ case "selectstart":
|
|
|
+ t.preventDefault();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ toArray: function () {
|
|
|
+ for (
|
|
|
+ var t,
|
|
|
+ e = [],
|
|
|
+ n = this.el.children,
|
|
|
+ o = 0,
|
|
|
+ i = n.length,
|
|
|
+ r = this.options;
|
|
|
+ o < i;
|
|
|
+ o++
|
|
|
+ )
|
|
|
+ P((t = n[o]), r.draggable, this.el, !1) &&
|
|
|
+ e.push(t.getAttribute(r.dataIdAttr) || Ft(t));
|
|
|
+ return e;
|
|
|
+ },
|
|
|
+ sort: function (t, e) {
|
|
|
+ var o = {},
|
|
|
+ i = this.el;
|
|
|
+ this.toArray().forEach(function (t, e) {
|
|
|
+ var n = i.children[e];
|
|
|
+ P(n, this.options.draggable, i, !1) && (o[t] = n);
|
|
|
+ }, this),
|
|
|
+ e && this.captureAnimationState(),
|
|
|
+ t.forEach(function (t) {
|
|
|
+ o[t] && (i.removeChild(o[t]), i.appendChild(o[t]));
|
|
|
+ }),
|
|
|
+ e && this.animateAll();
|
|
|
+ },
|
|
|
+ save: function () {
|
|
|
+ var t = this.options.store;
|
|
|
+ t && t.set && t.set(this);
|
|
|
+ },
|
|
|
+ closest: function (t, e) {
|
|
|
+ return P(t, e || this.options.draggable, this.el, !1);
|
|
|
+ },
|
|
|
+ option: function (t, e) {
|
|
|
+ var n = this.options;
|
|
|
+ if (void 0 === e) return n[t];
|
|
|
+ var o = O.modifyOption(this, t, e);
|
|
|
+ (n[t] = void 0 !== o ? o : e), "group" === t && Nt(n);
|
|
|
+ },
|
|
|
+ destroy: function () {
|
|
|
+ K("destroy", this);
|
|
|
+ var t = this.el;
|
|
|
+ (t[j] = null),
|
|
|
+ s(t, "mousedown", this._onTapStart),
|
|
|
+ s(t, "touchstart", this._onTapStart),
|
|
|
+ s(t, "pointerdown", this._onTapStart),
|
|
|
+ this.nativeDraggable &&
|
|
|
+ (s(t, "dragover", this), s(t, "dragenter", this)),
|
|
|
+ Array.prototype.forEach.call(
|
|
|
+ t.querySelectorAll("[draggable]"),
|
|
|
+ function (t) {
|
|
|
+ t.removeAttribute("draggable");
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ this._onDrop(),
|
|
|
+ this._disableDelayedDragEvents(),
|
|
|
+ bt.splice(bt.indexOf(this.el), 1),
|
|
|
+ (this.el = t = null);
|
|
|
+ },
|
|
|
+ _hideClone: function () {
|
|
|
+ if (!$) {
|
|
|
+ if ((K("hideClone", this), Rt.eventCanceled)) return;
|
|
|
+ R(Q, "display", "none"),
|
|
|
+ this.options.removeCloneOnHide &&
|
|
|
+ Q.parentNode &&
|
|
|
+ Q.parentNode.removeChild(Q),
|
|
|
+ ($ = !0);
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _showClone: function (t) {
|
|
|
+ if ("clone" === t.lastPutMode) {
|
|
|
+ if ($) {
|
|
|
+ if ((K("showClone", this), Rt.eventCanceled)) return;
|
|
|
+ z.parentNode != q || this.options.group.revertClone
|
|
|
+ ? V
|
|
|
+ ? q.insertBefore(Q, V)
|
|
|
+ : q.appendChild(Q)
|
|
|
+ : q.insertBefore(Q, z),
|
|
|
+ this.options.group.revertClone && this.animate(z, Q),
|
|
|
+ R(Q, "display", ""),
|
|
|
+ ($ = !1);
|
|
|
+ }
|
|
|
+ } else this._hideClone();
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _t &&
|
|
|
+ d(document, "touchmove", function (t) {
|
|
|
+ (Rt.active || vt) && t.cancelable && t.preventDefault();
|
|
|
+ }),
|
|
|
+ (Rt.utils = {
|
|
|
+ on: d,
|
|
|
+ off: s,
|
|
|
+ css: R,
|
|
|
+ find: g,
|
|
|
+ is: function (t, e) {
|
|
|
+ return !!P(t, e, t, !1);
|
|
|
+ },
|
|
|
+ extend: function (t, e) {
|
|
|
+ if (t && e) for (var n in e) e.hasOwnProperty(n) && (t[n] = e[n]);
|
|
|
+ return t;
|
|
|
+ },
|
|
|
+ throttle: D,
|
|
|
+ closest: P,
|
|
|
+ toggleClass: k,
|
|
|
+ clone: S,
|
|
|
+ index: F,
|
|
|
+ nextTick: Ht,
|
|
|
+ cancelNextTick: Lt,
|
|
|
+ detectDirection: Ot,
|
|
|
+ getChild: m
|
|
|
+ }),
|
|
|
+ (Rt.get = function (t) {
|
|
|
+ return t[j];
|
|
|
+ }),
|
|
|
+ (Rt.mount = function () {
|
|
|
+ for (var t = arguments.length, e = new Array(t), n = 0; n < t; n++)
|
|
|
+ e[n] = arguments[n];
|
|
|
+ e[0].constructor === Array && (e = e[0]),
|
|
|
+ e.forEach(function (t) {
|
|
|
+ if (!t.prototype || !t.prototype.constructor)
|
|
|
+ throw "Sortable: Mounted plugin must be a constructor function, not ".concat(
|
|
|
+ {}.toString.call(t)
|
|
|
+ );
|
|
|
+ t.utils && (Rt.utils = I({}, Rt.utils, t.utils)), O.mount(t);
|
|
|
+ });
|
|
|
+ }),
|
|
|
+ (Rt.create = function (t, e) {
|
|
|
+ return new Rt(t, e);
|
|
|
+ });
|
|
|
+ var jt,
|
|
|
+ Kt,
|
|
|
+ Wt,
|
|
|
+ zt,
|
|
|
+ Gt,
|
|
|
+ Ut,
|
|
|
+ qt = [],
|
|
|
+ Vt = !(Rt.version = "1.13.0");
|
|
|
+ function Zt() {
|
|
|
+ qt.forEach(function (t) {
|
|
|
+ clearInterval(t.pid);
|
|
|
+ }),
|
|
|
+ (qt = []);
|
|
|
+ }
|
|
|
+ function Qt() {
|
|
|
+ clearInterval(Ut);
|
|
|
+ }
|
|
|
+ function $t(t) {
|
|
|
+ var e = t.originalEvent,
|
|
|
+ n = t.putSortable,
|
|
|
+ o = t.dragEl,
|
|
|
+ i = t.activeSortable,
|
|
|
+ r = t.dispatchSortableEvent,
|
|
|
+ a = t.hideGhostForTarget,
|
|
|
+ l = t.unhideGhostForTarget;
|
|
|
+ if (e) {
|
|
|
+ var s = n || i;
|
|
|
+ a();
|
|
|
+ var c =
|
|
|
+ e.changedTouches && e.changedTouches.length ? e.changedTouches[0] : e,
|
|
|
+ u = document.elementFromPoint(c.clientX, c.clientY);
|
|
|
+ l(),
|
|
|
+ s &&
|
|
|
+ !s.el.contains(u) &&
|
|
|
+ (r("spill"), this.onSpill({ dragEl: o, putSortable: n }));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Jt,
|
|
|
+ te = D(function (n, t, e, o) {
|
|
|
+ if (t.scroll) {
|
|
|
+ var i,
|
|
|
+ r = (n.touches ? n.touches[0] : n).clientX,
|
|
|
+ a = (n.touches ? n.touches[0] : n).clientY,
|
|
|
+ l = t.scrollSensitivity,
|
|
|
+ s = t.scrollSpeed,
|
|
|
+ c = A(),
|
|
|
+ u = !1;
|
|
|
+ Kt !== e &&
|
|
|
+ ((Kt = e),
|
|
|
+ Zt(),
|
|
|
+ (jt = t.scroll),
|
|
|
+ (i = t.scrollFn),
|
|
|
+ !0 === jt && (jt = H(e, !0)));
|
|
|
+ var d = 0,
|
|
|
+ h = jt;
|
|
|
+ do {
|
|
|
+ var f = h,
|
|
|
+ p = X(f),
|
|
|
+ g = p.top,
|
|
|
+ v = p.bottom,
|
|
|
+ m = p.left,
|
|
|
+ b = p.right,
|
|
|
+ y = p.width,
|
|
|
+ w = p.height,
|
|
|
+ E = void 0,
|
|
|
+ D = void 0,
|
|
|
+ S = f.scrollWidth,
|
|
|
+ _ = f.scrollHeight,
|
|
|
+ C = R(f),
|
|
|
+ T = f.scrollLeft,
|
|
|
+ x = f.scrollTop;
|
|
|
+ D =
|
|
|
+ f === c
|
|
|
+ ? ((E =
|
|
|
+ y < S &&
|
|
|
+ ("auto" === C.overflowX ||
|
|
|
+ "scroll" === C.overflowX ||
|
|
|
+ "visible" === C.overflowX)),
|
|
|
+ w < _ &&
|
|
|
+ ("auto" === C.overflowY ||
|
|
|
+ "scroll" === C.overflowY ||
|
|
|
+ "visible" === C.overflowY))
|
|
|
+ : ((E =
|
|
|
+ y < S &&
|
|
|
+ ("auto" === C.overflowX || "scroll" === C.overflowX)),
|
|
|
+ w < _ && ("auto" === C.overflowY || "scroll" === C.overflowY));
|
|
|
+ var M =
|
|
|
+ E &&
|
|
|
+ (Math.abs(b - r) <= l && T + y < S) -
|
|
|
+ (Math.abs(m - r) <= l && !!T),
|
|
|
+ O =
|
|
|
+ D &&
|
|
|
+ (Math.abs(v - a) <= l && x + w < _) -
|
|
|
+ (Math.abs(g - a) <= l && !!x);
|
|
|
+ if (!qt[d]) for (var N = 0; N <= d; N++) qt[N] || (qt[N] = {});
|
|
|
+ (qt[d].vx == M && qt[d].vy == O && qt[d].el === f) ||
|
|
|
+ ((qt[d].el = f),
|
|
|
+ (qt[d].vx = M),
|
|
|
+ (qt[d].vy = O),
|
|
|
+ clearInterval(qt[d].pid),
|
|
|
+ (0 == M && 0 == O) ||
|
|
|
+ ((u = !0),
|
|
|
+ (qt[d].pid = setInterval(
|
|
|
+ function () {
|
|
|
+ o && 0 === this.layer && Rt.active._onTouchMove(Gt);
|
|
|
+ var t = qt[this.layer].vy ? qt[this.layer].vy * s : 0,
|
|
|
+ e = qt[this.layer].vx ? qt[this.layer].vx * s : 0;
|
|
|
+ ("function" == typeof i &&
|
|
|
+ "continue" !==
|
|
|
+ i.call(
|
|
|
+ Rt.dragged.parentNode[j],
|
|
|
+ e,
|
|
|
+ t,
|
|
|
+ n,
|
|
|
+ Gt,
|
|
|
+ qt[this.layer].el
|
|
|
+ )) ||
|
|
|
+ L(qt[this.layer].el, e, t);
|
|
|
+ }.bind({ layer: d }),
|
|
|
+ 24
|
|
|
+ )))),
|
|
|
+ d++;
|
|
|
+ } while (t.bubbleScroll && h !== c && (h = H(h, !1)));
|
|
|
+ Vt = u;
|
|
|
+ }
|
|
|
+ }, 30);
|
|
|
+ function ee() {}
|
|
|
+ function ne() {}
|
|
|
+ (ee.prototype = {
|
|
|
+ startIndex: null,
|
|
|
+ dragStart: function (t) {
|
|
|
+ var e = t.oldDraggableIndex;
|
|
|
+ this.startIndex = e;
|
|
|
+ },
|
|
|
+ onSpill: function (t) {
|
|
|
+ var e = t.dragEl,
|
|
|
+ n = t.putSortable;
|
|
|
+ this.sortable.captureAnimationState(), n && n.captureAnimationState();
|
|
|
+ var o = m(this.sortable.el, this.startIndex, this.options);
|
|
|
+ o ? this.sortable.el.insertBefore(e, o) : this.sortable.el.appendChild(e),
|
|
|
+ this.sortable.animateAll(),
|
|
|
+ n && n.animateAll();
|
|
|
+ },
|
|
|
+ drop: $t
|
|
|
+ }),
|
|
|
+ a(ee, { pluginName: "revertOnSpill" }),
|
|
|
+ (ne.prototype = {
|
|
|
+ onSpill: function (t) {
|
|
|
+ var e = t.dragEl,
|
|
|
+ n = t.putSortable || this.sortable;
|
|
|
+ n.captureAnimationState(),
|
|
|
+ e.parentNode && e.parentNode.removeChild(e),
|
|
|
+ n.animateAll();
|
|
|
+ },
|
|
|
+ drop: $t
|
|
|
+ }),
|
|
|
+ a(ne, { pluginName: "removeOnSpill" });
|
|
|
+ var oe,
|
|
|
+ ie,
|
|
|
+ re,
|
|
|
+ ae,
|
|
|
+ le,
|
|
|
+ se = [],
|
|
|
+ ce = [],
|
|
|
+ ue = !1,
|
|
|
+ de = !1,
|
|
|
+ he = !1;
|
|
|
+ function fe(o, i) {
|
|
|
+ ce.forEach(function (t, e) {
|
|
|
+ var n = i.children[t.sortableIndex + (o ? Number(e) : 0)];
|
|
|
+ n ? i.insertBefore(t, n) : i.appendChild(t);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ function pe() {
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t !== re && t.parentNode && t.parentNode.removeChild(t);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ Rt.mount(
|
|
|
+ new (function () {
|
|
|
+ function t() {
|
|
|
+ for (var t in ((this.defaults = {
|
|
|
+ scroll: !0,
|
|
|
+ scrollSensitivity: 30,
|
|
|
+ scrollSpeed: 10,
|
|
|
+ bubbleScroll: !0
|
|
|
+ }),
|
|
|
+ this))
|
|
|
+ "_" === t.charAt(0) &&
|
|
|
+ "function" == typeof this[t] &&
|
|
|
+ (this[t] = this[t].bind(this));
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ (t.prototype = {
|
|
|
+ dragStarted: function (t) {
|
|
|
+ var e = t.originalEvent;
|
|
|
+ this.sortable.nativeDraggable
|
|
|
+ ? d(document, "dragover", this._handleAutoScroll)
|
|
|
+ : this.options.supportPointer
|
|
|
+ ? d(document, "pointermove", this._handleFallbackAutoScroll)
|
|
|
+ : e.touches
|
|
|
+ ? d(document, "touchmove", this._handleFallbackAutoScroll)
|
|
|
+ : d(document, "mousemove", this._handleFallbackAutoScroll);
|
|
|
+ },
|
|
|
+ dragOverCompleted: function (t) {
|
|
|
+ var e = t.originalEvent;
|
|
|
+ this.options.dragOverBubble ||
|
|
|
+ e.rootEl ||
|
|
|
+ this._handleAutoScroll(e);
|
|
|
+ },
|
|
|
+ drop: function () {
|
|
|
+ this.sortable.nativeDraggable
|
|
|
+ ? s(document, "dragover", this._handleAutoScroll)
|
|
|
+ : (s(document, "pointermove", this._handleFallbackAutoScroll),
|
|
|
+ s(document, "touchmove", this._handleFallbackAutoScroll),
|
|
|
+ s(document, "mousemove", this._handleFallbackAutoScroll)),
|
|
|
+ Qt(),
|
|
|
+ Zt(),
|
|
|
+ clearTimeout(f),
|
|
|
+ (f = void 0);
|
|
|
+ },
|
|
|
+ nulling: function () {
|
|
|
+ (Gt = Kt = jt = Vt = Ut = Wt = zt = null), (qt.length = 0);
|
|
|
+ },
|
|
|
+ _handleFallbackAutoScroll: function (t) {
|
|
|
+ this._handleAutoScroll(t, !0);
|
|
|
+ },
|
|
|
+ _handleAutoScroll: function (e, n) {
|
|
|
+ var o = this,
|
|
|
+ i = (e.touches ? e.touches[0] : e).clientX,
|
|
|
+ r = (e.touches ? e.touches[0] : e).clientY,
|
|
|
+ t = document.elementFromPoint(i, r);
|
|
|
+ if (((Gt = e), n || E || w || u)) {
|
|
|
+ te(e, this.options, t, n);
|
|
|
+ var a = H(t, !0);
|
|
|
+ !Vt ||
|
|
|
+ (Ut && i === Wt && r === zt) ||
|
|
|
+ (Ut && Qt(),
|
|
|
+ (Ut = setInterval(function () {
|
|
|
+ var t = H(document.elementFromPoint(i, r), !0);
|
|
|
+ t !== a && ((a = t), Zt()), te(e, o.options, t, n);
|
|
|
+ }, 10)),
|
|
|
+ (Wt = i),
|
|
|
+ (zt = r));
|
|
|
+ } else {
|
|
|
+ if (!this.options.bubbleScroll || H(t, !0) === A())
|
|
|
+ return void Zt();
|
|
|
+ te(e, this.options, H(t, !1), !1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a(t, { pluginName: "scroll", initializeByDefault: !0 })
|
|
|
+ );
|
|
|
+ })()
|
|
|
+ ),
|
|
|
+ Rt.mount(ne, ee),
|
|
|
+ Rt.mount(
|
|
|
+ new (function () {
|
|
|
+ function t() {
|
|
|
+ this.defaults = { swapClass: "sortable-swap-highlight" };
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ (t.prototype = {
|
|
|
+ dragStart: function (t) {
|
|
|
+ var e = t.dragEl;
|
|
|
+ Jt = e;
|
|
|
+ },
|
|
|
+ dragOverValid: function (t) {
|
|
|
+ var e = t.completed,
|
|
|
+ n = t.target,
|
|
|
+ o = t.onMove,
|
|
|
+ i = t.activeSortable,
|
|
|
+ r = t.changed,
|
|
|
+ a = t.cancel;
|
|
|
+ if (i.options.swap) {
|
|
|
+ var l = this.sortable.el,
|
|
|
+ s = this.options;
|
|
|
+ if (n && n !== l) {
|
|
|
+ var c = Jt;
|
|
|
+ (Jt = !1 !== o(n) ? (k(n, s.swapClass, !0), n) : null),
|
|
|
+ c && c !== Jt && k(c, s.swapClass, !1);
|
|
|
+ }
|
|
|
+ r(), e(!0), a();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ drop: function (t) {
|
|
|
+ var e = t.activeSortable,
|
|
|
+ n = t.putSortable,
|
|
|
+ o = t.dragEl,
|
|
|
+ i = n || this.sortable,
|
|
|
+ r = this.options;
|
|
|
+ Jt && k(Jt, r.swapClass, !1),
|
|
|
+ Jt &&
|
|
|
+ (r.swap || (n && n.options.swap)) &&
|
|
|
+ o !== Jt &&
|
|
|
+ (i.captureAnimationState(),
|
|
|
+ i !== e && e.captureAnimationState(),
|
|
|
+ (function (t, e) {
|
|
|
+ var n,
|
|
|
+ o,
|
|
|
+ i = t.parentNode,
|
|
|
+ r = e.parentNode;
|
|
|
+ if (!i || !r || i.isEqualNode(e) || r.isEqualNode(t))
|
|
|
+ return;
|
|
|
+ (n = F(t)), (o = F(e)), i.isEqualNode(r) && n < o && o++;
|
|
|
+ i.insertBefore(e, i.children[n]),
|
|
|
+ r.insertBefore(t, r.children[o]);
|
|
|
+ })(o, Jt),
|
|
|
+ i.animateAll(),
|
|
|
+ i !== e && e.animateAll());
|
|
|
+ },
|
|
|
+ nulling: function () {
|
|
|
+ Jt = null;
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a(t, {
|
|
|
+ pluginName: "swap",
|
|
|
+ eventProperties: function () {
|
|
|
+ return { swapItem: Jt };
|
|
|
+ }
|
|
|
+ })
|
|
|
+ );
|
|
|
+ })()
|
|
|
+ ),
|
|
|
+ Rt.mount(
|
|
|
+ new (function () {
|
|
|
+ function t(o) {
|
|
|
+ for (var t in this)
|
|
|
+ "_" === t.charAt(0) &&
|
|
|
+ "function" == typeof this[t] &&
|
|
|
+ (this[t] = this[t].bind(this));
|
|
|
+ o.options.supportPointer
|
|
|
+ ? d(document, "pointerup", this._deselectMultiDrag)
|
|
|
+ : (d(document, "mouseup", this._deselectMultiDrag),
|
|
|
+ d(document, "touchend", this._deselectMultiDrag)),
|
|
|
+ d(document, "keydown", this._checkKeyDown),
|
|
|
+ d(document, "keyup", this._checkKeyUp),
|
|
|
+ (this.defaults = {
|
|
|
+ selectedClass: "sortable-selected",
|
|
|
+ multiDragKey: null,
|
|
|
+ setData: function (t, e) {
|
|
|
+ var n = "";
|
|
|
+ se.length && ie === o
|
|
|
+ ? se.forEach(function (t, e) {
|
|
|
+ n += (e ? ", " : "") + t.textContent;
|
|
|
+ })
|
|
|
+ : (n = e.textContent),
|
|
|
+ t.setData("Text", n);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ (t.prototype = {
|
|
|
+ multiDragKeyDown: !1,
|
|
|
+ isMultiDrag: !1,
|
|
|
+ delayStartGlobal: function (t) {
|
|
|
+ var e = t.dragEl;
|
|
|
+ re = e;
|
|
|
+ },
|
|
|
+ delayEnded: function () {
|
|
|
+ this.isMultiDrag = ~se.indexOf(re);
|
|
|
+ },
|
|
|
+ setupClone: function (t) {
|
|
|
+ var e = t.sortable,
|
|
|
+ n = t.cancel;
|
|
|
+ if (this.isMultiDrag) {
|
|
|
+ for (var o = 0; o < se.length; o++)
|
|
|
+ ce.push(S(se[o])),
|
|
|
+ (ce[o].sortableIndex = se[o].sortableIndex),
|
|
|
+ (ce[o].draggable = !1),
|
|
|
+ (ce[o].style["will-change"] = ""),
|
|
|
+ k(ce[o], this.options.selectedClass, !1),
|
|
|
+ se[o] === re && k(ce[o], this.options.chosenClass, !1);
|
|
|
+ e._hideClone(), n();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ clone: function (t) {
|
|
|
+ var e = t.sortable,
|
|
|
+ n = t.rootEl,
|
|
|
+ o = t.dispatchSortableEvent,
|
|
|
+ i = t.cancel;
|
|
|
+ this.isMultiDrag &&
|
|
|
+ (this.options.removeCloneOnHide ||
|
|
|
+ (se.length && ie === e && (fe(!0, n), o("clone"), i())));
|
|
|
+ },
|
|
|
+ showClone: function (t) {
|
|
|
+ var e = t.cloneNowShown,
|
|
|
+ n = t.rootEl,
|
|
|
+ o = t.cancel;
|
|
|
+ this.isMultiDrag &&
|
|
|
+ (fe(!1, n),
|
|
|
+ ce.forEach(function (t) {
|
|
|
+ R(t, "display", "");
|
|
|
+ }),
|
|
|
+ e(),
|
|
|
+ (le = !1),
|
|
|
+ o());
|
|
|
+ },
|
|
|
+ hideClone: function (t) {
|
|
|
+ var e = this,
|
|
|
+ n = (t.sortable, t.cloneNowHidden),
|
|
|
+ o = t.cancel;
|
|
|
+ this.isMultiDrag &&
|
|
|
+ (ce.forEach(function (t) {
|
|
|
+ R(t, "display", "none"),
|
|
|
+ e.options.removeCloneOnHide &&
|
|
|
+ t.parentNode &&
|
|
|
+ t.parentNode.removeChild(t);
|
|
|
+ }),
|
|
|
+ n(),
|
|
|
+ (le = !0),
|
|
|
+ o());
|
|
|
+ },
|
|
|
+ dragStartGlobal: function (t) {
|
|
|
+ t.sortable;
|
|
|
+ !this.isMultiDrag && ie && ie.multiDrag._deselectMultiDrag(),
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t.sortableIndex = F(t);
|
|
|
+ }),
|
|
|
+ (se = se.sort(function (t, e) {
|
|
|
+ return t.sortableIndex - e.sortableIndex;
|
|
|
+ })),
|
|
|
+ (he = !0);
|
|
|
+ },
|
|
|
+ dragStarted: function (t) {
|
|
|
+ var e = this,
|
|
|
+ n = t.sortable;
|
|
|
+ if (this.isMultiDrag) {
|
|
|
+ if (
|
|
|
+ this.options.sort &&
|
|
|
+ (n.captureAnimationState(), this.options.animation)
|
|
|
+ ) {
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t !== re && R(t, "position", "absolute");
|
|
|
+ });
|
|
|
+ var o = X(re, !1, !0, !0);
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t !== re && _(t, o);
|
|
|
+ }),
|
|
|
+ (ue = de = !0);
|
|
|
+ }
|
|
|
+ n.animateAll(function () {
|
|
|
+ (ue = de = !1),
|
|
|
+ e.options.animation &&
|
|
|
+ se.forEach(function (t) {
|
|
|
+ C(t);
|
|
|
+ }),
|
|
|
+ e.options.sort && pe();
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dragOver: function (t) {
|
|
|
+ var e = t.target,
|
|
|
+ n = t.completed,
|
|
|
+ o = t.cancel;
|
|
|
+ de && ~se.indexOf(e) && (n(!1), o());
|
|
|
+ },
|
|
|
+ revert: function (t) {
|
|
|
+ var e = t.fromSortable,
|
|
|
+ n = t.rootEl,
|
|
|
+ o = t.sortable,
|
|
|
+ i = t.dragRect;
|
|
|
+ 1 < se.length &&
|
|
|
+ (se.forEach(function (t) {
|
|
|
+ o.addAnimationState({ target: t, rect: de ? X(t) : i }),
|
|
|
+ C(t),
|
|
|
+ (t.fromRect = i),
|
|
|
+ e.removeAnimationState(t);
|
|
|
+ }),
|
|
|
+ (de = !1),
|
|
|
+ (function (o, i) {
|
|
|
+ se.forEach(function (t, e) {
|
|
|
+ var n = i.children[t.sortableIndex + (o ? Number(e) : 0)];
|
|
|
+ n ? i.insertBefore(t, n) : i.appendChild(t);
|
|
|
+ });
|
|
|
+ })(!this.options.removeCloneOnHide, n));
|
|
|
+ },
|
|
|
+ dragOverCompleted: function (t) {
|
|
|
+ var e = t.sortable,
|
|
|
+ n = t.isOwner,
|
|
|
+ o = t.insertion,
|
|
|
+ i = t.activeSortable,
|
|
|
+ r = t.parentEl,
|
|
|
+ a = t.putSortable,
|
|
|
+ l = this.options;
|
|
|
+ if (o) {
|
|
|
+ if (
|
|
|
+ (n && i._hideClone(),
|
|
|
+ (ue = !1),
|
|
|
+ l.animation &&
|
|
|
+ 1 < se.length &&
|
|
|
+ (de || (!n && !i.options.sort && !a)))
|
|
|
+ ) {
|
|
|
+ var s = X(re, !1, !0, !0);
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t !== re && (_(t, s), r.appendChild(t));
|
|
|
+ }),
|
|
|
+ (de = !0);
|
|
|
+ }
|
|
|
+ if (!n)
|
|
|
+ if ((de || pe(), 1 < se.length)) {
|
|
|
+ var c = le;
|
|
|
+ i._showClone(e),
|
|
|
+ i.options.animation &&
|
|
|
+ !le &&
|
|
|
+ c &&
|
|
|
+ ce.forEach(function (t) {
|
|
|
+ i.addAnimationState({ target: t, rect: ae }),
|
|
|
+ (t.fromRect = ae),
|
|
|
+ (t.thisAnimationDuration = null);
|
|
|
+ });
|
|
|
+ } else i._showClone(e);
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dragOverAnimationCapture: function (t) {
|
|
|
+ var e = t.dragRect,
|
|
|
+ n = t.isOwner,
|
|
|
+ o = t.activeSortable;
|
|
|
+ if (
|
|
|
+ (se.forEach(function (t) {
|
|
|
+ t.thisAnimationDuration = null;
|
|
|
+ }),
|
|
|
+ o.options.animation && !n && o.multiDrag.isMultiDrag)
|
|
|
+ ) {
|
|
|
+ ae = a({}, e);
|
|
|
+ var i = v(re, !0);
|
|
|
+ (ae.top -= i.f), (ae.left -= i.e);
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dragOverAnimationComplete: function () {
|
|
|
+ de && ((de = !1), pe());
|
|
|
+ },
|
|
|
+ drop: function (t) {
|
|
|
+ var e = t.originalEvent,
|
|
|
+ n = t.rootEl,
|
|
|
+ o = t.parentEl,
|
|
|
+ i = t.sortable,
|
|
|
+ r = t.dispatchSortableEvent,
|
|
|
+ a = t.oldIndex,
|
|
|
+ l = t.putSortable,
|
|
|
+ s = l || this.sortable;
|
|
|
+ if (e) {
|
|
|
+ var c = this.options,
|
|
|
+ u = o.children;
|
|
|
+ if (!he)
|
|
|
+ if (
|
|
|
+ (c.multiDragKey &&
|
|
|
+ !this.multiDragKeyDown &&
|
|
|
+ this._deselectMultiDrag(),
|
|
|
+ k(re, c.selectedClass, !~se.indexOf(re)),
|
|
|
+ ~se.indexOf(re))
|
|
|
+ )
|
|
|
+ se.splice(se.indexOf(re), 1),
|
|
|
+ (oe = null),
|
|
|
+ N({
|
|
|
+ sortable: i,
|
|
|
+ rootEl: n,
|
|
|
+ name: "deselect",
|
|
|
+ targetEl: re,
|
|
|
+ originalEvt: e
|
|
|
+ });
|
|
|
+ else {
|
|
|
+ if (
|
|
|
+ (se.push(re),
|
|
|
+ N({
|
|
|
+ sortable: i,
|
|
|
+ rootEl: n,
|
|
|
+ name: "select",
|
|
|
+ targetEl: re,
|
|
|
+ originalEvt: e
|
|
|
+ }),
|
|
|
+ e.shiftKey && oe && i.el.contains(oe))
|
|
|
+ ) {
|
|
|
+ var d,
|
|
|
+ h,
|
|
|
+ f = F(oe),
|
|
|
+ p = F(re);
|
|
|
+ if (~f && ~p && f !== p)
|
|
|
+ for (
|
|
|
+ d = f < p ? ((h = f), p) : ((h = p), f + 1);
|
|
|
+ h < d;
|
|
|
+ h++
|
|
|
+ )
|
|
|
+ ~se.indexOf(u[h]) ||
|
|
|
+ (k(u[h], c.selectedClass, !0),
|
|
|
+ se.push(u[h]),
|
|
|
+ N({
|
|
|
+ sortable: i,
|
|
|
+ rootEl: n,
|
|
|
+ name: "select",
|
|
|
+ targetEl: u[h],
|
|
|
+ originalEvt: e
|
|
|
+ }));
|
|
|
+ } else oe = re;
|
|
|
+ ie = s;
|
|
|
+ }
|
|
|
+ if (he && this.isMultiDrag) {
|
|
|
+ if ((o[j].options.sort || o !== n) && 1 < se.length) {
|
|
|
+ var g = X(re),
|
|
|
+ v = F(re, ":not(." + this.options.selectedClass + ")");
|
|
|
+ if (
|
|
|
+ (!ue && c.animation && (re.thisAnimationDuration = null),
|
|
|
+ s.captureAnimationState(),
|
|
|
+ !ue &&
|
|
|
+ (c.animation &&
|
|
|
+ ((re.fromRect = g),
|
|
|
+ se.forEach(function (t) {
|
|
|
+ if (((t.thisAnimationDuration = null), t !== re)) {
|
|
|
+ var e = de ? X(t) : g;
|
|
|
+ (t.fromRect = e),
|
|
|
+ s.addAnimationState({ target: t, rect: e });
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ pe(),
|
|
|
+ se.forEach(function (t) {
|
|
|
+ u[v] ? o.insertBefore(t, u[v]) : o.appendChild(t),
|
|
|
+ v++;
|
|
|
+ }),
|
|
|
+ a === F(re)))
|
|
|
+ ) {
|
|
|
+ var m = !1;
|
|
|
+ se.forEach(function (t) {
|
|
|
+ t.sortableIndex === F(t) || (m = !0);
|
|
|
+ }),
|
|
|
+ m && r("update");
|
|
|
+ }
|
|
|
+ se.forEach(function (t) {
|
|
|
+ C(t);
|
|
|
+ }),
|
|
|
+ s.animateAll();
|
|
|
+ }
|
|
|
+ ie = s;
|
|
|
+ }
|
|
|
+ (n === o || (l && "clone" !== l.lastPutMode)) &&
|
|
|
+ ce.forEach(function (t) {
|
|
|
+ t.parentNode && t.parentNode.removeChild(t);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ nullingGlobal: function () {
|
|
|
+ (this.isMultiDrag = he = !1), (ce.length = 0);
|
|
|
+ },
|
|
|
+ destroyGlobal: function () {
|
|
|
+ this._deselectMultiDrag(),
|
|
|
+ s(document, "pointerup", this._deselectMultiDrag),
|
|
|
+ s(document, "mouseup", this._deselectMultiDrag),
|
|
|
+ s(document, "touchend", this._deselectMultiDrag),
|
|
|
+ s(document, "keydown", this._checkKeyDown),
|
|
|
+ s(document, "keyup", this._checkKeyUp);
|
|
|
+ },
|
|
|
+ _deselectMultiDrag: function (t) {
|
|
|
+ if (
|
|
|
+ !(
|
|
|
+ (void 0 !== he && he) ||
|
|
|
+ ie !== this.sortable ||
|
|
|
+ (t &&
|
|
|
+ P(
|
|
|
+ t.target,
|
|
|
+ this.options.draggable,
|
|
|
+ this.sortable.el,
|
|
|
+ !1
|
|
|
+ )) ||
|
|
|
+ (t && 0 !== t.button)
|
|
|
+ )
|
|
|
+ )
|
|
|
+ for (; se.length; ) {
|
|
|
+ var e = se[0];
|
|
|
+ k(e, this.options.selectedClass, !1),
|
|
|
+ se.shift(),
|
|
|
+ N({
|
|
|
+ sortable: this.sortable,
|
|
|
+ rootEl: this.sortable.el,
|
|
|
+ name: "deselect",
|
|
|
+ targetEl: e,
|
|
|
+ originalEvt: t
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _checkKeyDown: function (t) {
|
|
|
+ t.key === this.options.multiDragKey &&
|
|
|
+ (this.multiDragKeyDown = !0);
|
|
|
+ },
|
|
|
+ _checkKeyUp: function (t) {
|
|
|
+ t.key === this.options.multiDragKey &&
|
|
|
+ (this.multiDragKeyDown = !1);
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a(t, {
|
|
|
+ pluginName: "multiDrag",
|
|
|
+ utils: {
|
|
|
+ select: function (t) {
|
|
|
+ var e = t.parentNode[j];
|
|
|
+ e &&
|
|
|
+ e.options.multiDrag &&
|
|
|
+ !~se.indexOf(t) &&
|
|
|
+ (ie &&
|
|
|
+ ie !== e &&
|
|
|
+ (ie.multiDrag._deselectMultiDrag(), (ie = e)),
|
|
|
+ k(t, e.options.selectedClass, !0),
|
|
|
+ se.push(t));
|
|
|
+ },
|
|
|
+ deselect: function (t) {
|
|
|
+ var e = t.parentNode[j],
|
|
|
+ n = se.indexOf(t);
|
|
|
+ e &&
|
|
|
+ e.options.multiDrag &&
|
|
|
+ ~n &&
|
|
|
+ (k(t, e.options.selectedClass, !1), se.splice(n, 1));
|
|
|
+ }
|
|
|
+ },
|
|
|
+ eventProperties: function () {
|
|
|
+ var n = this,
|
|
|
+ o = [],
|
|
|
+ i = [];
|
|
|
+ return (
|
|
|
+ se.forEach(function (t) {
|
|
|
+ var e;
|
|
|
+ o.push({ multiDragElement: t, index: t.sortableIndex }),
|
|
|
+ (e =
|
|
|
+ de && t !== re
|
|
|
+ ? -1
|
|
|
+ : de
|
|
|
+ ? F(t, ":not(." + n.options.selectedClass + ")")
|
|
|
+ : F(t)),
|
|
|
+ i.push({ multiDragElement: t, index: e });
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ items: e(se),
|
|
|
+ clones: [].concat(ce),
|
|
|
+ oldIndicies: o,
|
|
|
+ newIndicies: i
|
|
|
+ }
|
|
|
+ );
|
|
|
+ },
|
|
|
+ optionListeners: {
|
|
|
+ multiDragKey: function (t) {
|
|
|
+ return (
|
|
|
+ "ctrl" === (t = t.toLowerCase())
|
|
|
+ ? (t = "Control")
|
|
|
+ : 1 < t.length &&
|
|
|
+ (t = t.charAt(0).toUpperCase() + t.substr(1)),
|
|
|
+ t
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ );
|
|
|
+ })()
|
|
|
+ ),
|
|
|
+ Rt
|
|
|
+ );
|
|
|
+});
|
xiaoxian521