form-custom-test 3.0.11 → 3.0.13

package/dist/designer.es.js

@@ -17,11 +17,16 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import require$$0$1, { reactive, openBlock, createElementBlock, normalizeClass, createElementVNode, toDisplayString, createCommentVNode, resolveComponent, createBlock, normalizeStyle, withCtx, createVNode, createTextVNode, Fragment, renderList, renderSlot, withModifiers, createSlots, watch, ref, onBeforeUnmount, onMounted, onUnmounted, withDirectives, mergeProps, resolveDynamicComponent, vShow, resolveDirective, defineComponent, isVNode } from "vue";
+var _a;
+import * as vue from "vue";
+import { reactive, openBlock, createElementBlock, normalizeClass, createElementVNode, toDisplayString, createCommentVNode, resolveComponent, createBlock, normalizeStyle, withCtx, createVNode, createTextVNode, Fragment, renderList, renderSlot, withModifiers, createSlots, watch, ref, onBeforeUnmount, onMounted, onUnmounted, withDirectives, mergeProps, resolveDynamicComponent, vShow, resolveDirective, defineComponent, isVNode } from "vue";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
+function getDefaultExportFromNamespaceIfPresent(n) {
+  return n && Object.prototype.hasOwnProperty.call(n, "default") ? n["default"] : n;
+}
 var axios$2 = { exports: {} };
 var bind$2 = function bind2(fn, thisArg) {
   return function wrap() {
@@ -1064,8 +1069,7 @@ axios$1.spread = spread;
 axios$1.isAxiosError = isAxiosError;
 axios$2.exports = axios$1;
 axios$2.exports.default = axios$1;
-var require$$0 = axios$2.exports;
-var axios = require$$0;
+var axios = axios$2.exports;
 const containers = [
   {
     type: "grid",
@@ -9740,7 +9744,7 @@ var quill = { exports: {} };
         function _interopRequireDefault(obj) {
           return obj && obj.__esModule ? obj : { default: obj };
         }
-        function _toConsumableArray(arr) {
+        function _toConsumableArray2(arr) {
           if (Array.isArray(arr)) {
             for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
               arr2[i] = arr[i];
@@ -9977,8 +9981,8 @@ var quill = { exports: {} };
                   return index2 + blot.index(node, offset);
                 }
               });
-              var end = Math.min(Math.max.apply(Math, _toConsumableArray(indexes)), this.scroll.length() - 1);
-              var start = Math.min.apply(Math, [end].concat(_toConsumableArray(indexes)));
+              var end = Math.min(Math.max.apply(Math, _toConsumableArray2(indexes)), this.scroll.length() - 1);
+              var start = Math.min.apply(Math, [end].concat(_toConsumableArray2(indexes)));
               return new Range(start, end - start);
             }
           }, {
@@ -10106,7 +10110,7 @@ var quill = { exports: {} };
               debug.info("setRange", range);
               if (range != null) {
                 var args = this.rangeToNative(range);
-                this.setNativeRange.apply(this, _toConsumableArray(args).concat([force]));
+                this.setNativeRange.apply(this, _toConsumableArray2(args).concat([force]));
               } else {
                 this.setNativeRange(null);
               }
@@ -10318,7 +10322,7 @@ var quill = { exports: {} };
             });
           };
           ContainerBlot2.prototype.descendant = function(criteria, index2) {
-            var _a = this.children.find(index2), child = _a[0], offset = _a[1];
+            var _a2 = this.children.find(index2), child = _a2[0], offset = _a2[1];
             if (criteria.blotName == null && criteria(child) || criteria.blotName != null && child instanceof criteria) {
               return [child, offset];
             } else if (child instanceof ContainerBlot2) {
@@ -10359,7 +10363,7 @@ var quill = { exports: {} };
             });
           };
           ContainerBlot2.prototype.insertAt = function(index2, value2, def) {
-            var _a = this.children.find(index2), child = _a[0], offset = _a[1];
+            var _a2 = this.children.find(index2), child = _a2[0], offset = _a2[1];
             if (child) {
               child.insertAt(offset, value2, def);
             } else {
@@ -10401,7 +10405,7 @@ var quill = { exports: {} };
             if (inclusive === void 0) {
               inclusive = false;
             }
-            var _a = this.children.find(index2, inclusive), child = _a[0], offset = _a[1];
+            var _a2 = this.children.find(index2, inclusive), child = _a2[0], offset = _a2[1];
             var position = [[this, index2]];
             if (child instanceof ContainerBlot2) {
               return position.concat(child.path(offset, inclusive));
@@ -10628,8 +10632,8 @@ var quill = { exports: {} };
             return [this.parent.domNode, offset];
           };
           LeafBlot2.prototype.value = function() {
-            var _a;
-            return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a;
+            var _a2;
+            return _a2 = {}, _a2[this.statics.blotName] = this.statics.value(this.domNode) || true, _a2;
           };
           LeafBlot2.scope = Registry.Scope.INLINE_BLOT;
           return LeafBlot2;
@@ -14046,7 +14050,7 @@ var quill = { exports: {} };
           LinkedList2.prototype.forEachAt = function(index2, length, callback2) {
             if (length <= 0)
               return;
-            var _a = this.find(index2), startNode = _a[0], offset = _a[1];
+            var _a2 = this.find(index2), startNode = _a2[0], offset = _a2[1];
             var cur, curIndex = index2 - offset, next = this.iterator(startNode);
             while ((cur = next()) && curIndex < index2 + length) {
               var curLength = cur.length();
@@ -23981,7 +23985,7 @@ var ace$2 = { exports: {} };
         }
       };
       PopupManager2.prototype.updatePopups = function() {
-        var e_1, _a, e_2, _b;
+        var e_1, _a2, e_2, _b;
         this.popups.sort(function(a, b) {
           return b.priority - a.priority;
         });
@@ -24019,8 +24023,8 @@ var ace$2 = { exports: {} };
           e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (_d && !_d.done && (_a = _c.return))
-              _a.call(_c);
+            if (_d && !_d.done && (_a2 = _c.return))
+              _a2.call(_c);
           } finally {
             if (e_1)
               throw e_1.error;
@@ -24376,7 +24380,7 @@ var ace$2 = { exports: {} };
         configurable: true
       });
       GutterTooltip2.prototype.showTooltip = function(row) {
-        var _a;
+        var _a2;
         var gutter = this.editor.renderer.$gutterLayer;
         var annotationsInRow = gutter.$annotations[row];
         var annotation;
@@ -24416,7 +24420,7 @@ var ace$2 = { exports: {} };
         for (var i = 0; i < annotation.displayText.length; i++) {
           var lineElement = dom.createElement("span");
           var iconElement = dom.createElement("span");
-          (_a = iconElement.classList).add.apply(_a, ["ace_".concat(annotation.type[i]), iconClassName]);
+          (_a2 = iconElement.classList).add.apply(_a2, ["ace_".concat(annotation.type[i]), iconClassName]);
           iconElement.setAttribute("aria-label", "".concat(GutterTooltip2.annotationLabels[annotation.type[i].replace("_fold", "")].singular));
           iconElement.setAttribute("role", "img");
           iconElement.appendChild(dom.createTextNode(" "));
@@ -24501,7 +24505,7 @@ var ace$2 = { exports: {} };
         _super.prototype.hide.call(this, e);
       };
       GutterTooltip2.annotationsToSummaryString = function(annotations) {
-        var e_1, _a;
+        var e_1, _a2;
         var summary = [];
         var annotationTypes = ["error", "security", "warning", "info", "hint"];
         try {
@@ -24516,8 +24520,8 @@ var ace$2 = { exports: {} };
           e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (annotationTypes_1_1 && !annotationTypes_1_1.done && (_a = annotationTypes_1.return))
-              _a.call(annotationTypes_1);
+            if (annotationTypes_1_1 && !annotationTypes_1_1.done && (_a2 = annotationTypes_1.return))
+              _a2.call(annotationTypes_1);
           } finally {
             if (e_1)
               throw e_1.error;
@@ -36233,7 +36237,7 @@ var ace$2 = { exports: {} };
         }
       };
       Editor2.prototype.findLinkAt = function(row, column) {
-        var e_1, _a;
+        var e_1, _a2;
         var line = this.session.getLine(row);
         var wordParts = line.split(/((?:https?|ftp):\/\/[\S]+)/);
         var columnPosition = column;
@@ -36256,8 +36260,8 @@ var ace$2 = { exports: {} };
           e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (wordParts_1_1 && !wordParts_1_1.done && (_a = wordParts_1.return))
-              _a.call(wordParts_1);
+            if (wordParts_1_1 && !wordParts_1_1.done && (_a2 = wordParts_1.return))
+              _a2.call(wordParts_1);
           } finally {
             if (e_1)
               throw e_1.error;
@@ -37786,8 +37790,8 @@ var ace$2 = { exports: {} };
         }
         return cell;
       };
-      Gutter2.prototype.$addCustomWidget = function(row, _a, cell) {
-        var className = _a.className, label = _a.label, title = _a.title, callbacks = _a.callbacks;
+      Gutter2.prototype.$addCustomWidget = function(row, _a2, cell) {
+        var className = _a2.className, label = _a2.label, title = _a2.title, callbacks = _a2.callbacks;
         this.session.$gutterCustomWidgets[row] = { className, label, title, callbacks };
         this.$hideFoldWidget(row, cell);
         var rowCell = cell || this.$getGutterCell(row);
@@ -57261,6 +57265,7 @@ function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
 }
 var VFormDesigner = /* @__PURE__ */ _export_sfc$1(_sfc_main$c, [["render", _sfc_render$c], ["__scopeId", "data-v-26b2429d"]]);
 var vuedraggable_umd = { exports: {} };
+var require$$0 = /* @__PURE__ */ getDefaultExportFromNamespaceIfPresent(vue);
 /**!
  * Sortable 1.14.0
  * @author	RubaXa   <trash@rubaxa.org>
@@ -57369,6 +57374,40 @@ function _objectWithoutProperties(source2, excluded) {
   }
   return target;
 }
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr))
+    return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 var version = "1.14.0";
 function userAgent(pattern2) {
   if (typeof window !== "undefined" && window.navigator) {
@@ -57683,6 +57722,20 @@ function clone(el) {
     return el.cloneNode(true);
   }
 }
+function setRect(el, rect) {
+  css(el, "position", "absolute");
+  css(el, "top", rect.top);
+  css(el, "left", rect.left);
+  css(el, "width", rect.width);
+  css(el, "height", rect.height);
+}
+function unsetRect(el) {
+  css(el, "position", "");
+  css(el, "top", "");
+  css(el, "left", "");
+  css(el, "width", "");
+  css(el, "height", "");
+}
 var expando = "Sortable" + new Date().getTime();
 function AnimationStateManager() {
   var animationStates = [], animationCallbackId;
@@ -59181,7 +59234,7 @@ function AutoScrollPlugin() {
     }
   }
   AutoScroll.prototype = {
-    dragStarted: function dragStarted(_ref) {
+    dragStarted: function dragStarted2(_ref) {
       var originalEvent = _ref.originalEvent;
       if (this.sortable.nativeDraggable) {
         on(document, "dragover", this._handleAutoScroll);
@@ -59387,11 +59440,574 @@ Remove.prototype = {
 _extends(Remove, {
   pluginName: "removeOnSpill"
 });
+var lastSwapEl;
+function SwapPlugin() {
+  function Swap() {
+    this.defaults = {
+      swapClass: "sortable-swap-highlight"
+    };
+  }
+  Swap.prototype = {
+    dragStart: function dragStart2(_ref) {
+      var dragEl2 = _ref.dragEl;
+      lastSwapEl = dragEl2;
+    },
+    dragOverValid: function dragOverValid(_ref2) {
+      var completed = _ref2.completed, target = _ref2.target, onMove = _ref2.onMove, activeSortable = _ref2.activeSortable, changed = _ref2.changed, cancel = _ref2.cancel;
+      if (!activeSortable.options.swap)
+        return;
+      var el = this.sortable.el, options = this.options;
+      if (target && target !== el) {
+        var prevSwapEl = lastSwapEl;
+        if (onMove(target) !== false) {
+          toggleClass(target, options.swapClass, true);
+          lastSwapEl = target;
+        } else {
+          lastSwapEl = null;
+        }
+        if (prevSwapEl && prevSwapEl !== lastSwapEl) {
+          toggleClass(prevSwapEl, options.swapClass, false);
+        }
+      }
+      changed();
+      completed(true);
+      cancel();
+    },
+    drop: function drop3(_ref3) {
+      var activeSortable = _ref3.activeSortable, putSortable2 = _ref3.putSortable, dragEl2 = _ref3.dragEl;
+      var toSortable = putSortable2 || this.sortable;
+      var options = this.options;
+      lastSwapEl && toggleClass(lastSwapEl, options.swapClass, false);
+      if (lastSwapEl && (options.swap || putSortable2 && putSortable2.options.swap)) {
+        if (dragEl2 !== lastSwapEl) {
+          toSortable.captureAnimationState();
+          if (toSortable !== activeSortable)
+            activeSortable.captureAnimationState();
+          swapNodes(dragEl2, lastSwapEl);
+          toSortable.animateAll();
+          if (toSortable !== activeSortable)
+            activeSortable.animateAll();
+        }
+      }
+    },
+    nulling: function nulling() {
+      lastSwapEl = null;
+    }
+  };
+  return _extends(Swap, {
+    pluginName: "swap",
+    eventProperties: function eventProperties() {
+      return {
+        swapItem: lastSwapEl
+      };
+    }
+  });
+}
+function swapNodes(n1, n2) {
+  var p1 = n1.parentNode, p2 = n2.parentNode, i1, i2;
+  if (!p1 || !p2 || p1.isEqualNode(n2) || p2.isEqualNode(n1))
+    return;
+  i1 = index(n1);
+  i2 = index(n2);
+  if (p1.isEqualNode(p2) && i1 < i2) {
+    i2++;
+  }
+  p1.insertBefore(n2, p1.children[i1]);
+  p2.insertBefore(n1, p2.children[i2]);
+}
+var multiDragElements = [], multiDragClones = [], lastMultiDragSelect, multiDragSortable, initialFolding = false, folding = false, dragStarted = false, dragEl$1, clonesFromRect, clonesHidden;
+function MultiDragPlugin() {
+  function MultiDrag(sortable) {
+    for (var fn in this) {
+      if (fn.charAt(0) === "_" && typeof this[fn] === "function") {
+        this[fn] = this[fn].bind(this);
+      }
+    }
+    if (sortable.options.supportPointer) {
+      on(document, "pointerup", this._deselectMultiDrag);
+    } else {
+      on(document, "mouseup", this._deselectMultiDrag);
+      on(document, "touchend", this._deselectMultiDrag);
+    }
+    on(document, "keydown", this._checkKeyDown);
+    on(document, "keyup", this._checkKeyUp);
+    this.defaults = {
+      selectedClass: "sortable-selected",
+      multiDragKey: null,
+      setData: function setData(dataTransfer, dragEl2) {
+        var data2 = "";
+        if (multiDragElements.length && multiDragSortable === sortable) {
+          multiDragElements.forEach(function(multiDragElement, i) {
+            data2 += (!i ? "" : ", ") + multiDragElement.textContent;
+          });
+        } else {
+          data2 = dragEl2.textContent;
+        }
+        dataTransfer.setData("Text", data2);
+      }
+    };
+  }
+  MultiDrag.prototype = {
+    multiDragKeyDown: false,
+    isMultiDrag: false,
+    delayStartGlobal: function delayStartGlobal(_ref) {
+      var dragged = _ref.dragEl;
+      dragEl$1 = dragged;
+    },
+    delayEnded: function delayEnded() {
+      this.isMultiDrag = ~multiDragElements.indexOf(dragEl$1);
+    },
+    setupClone: function setupClone(_ref2) {
+      var sortable = _ref2.sortable, cancel = _ref2.cancel;
+      if (!this.isMultiDrag)
+        return;
+      for (var i = 0; i < multiDragElements.length; i++) {
+        multiDragClones.push(clone(multiDragElements[i]));
+        multiDragClones[i].sortableIndex = multiDragElements[i].sortableIndex;
+        multiDragClones[i].draggable = false;
+        multiDragClones[i].style["will-change"] = "";
+        toggleClass(multiDragClones[i], this.options.selectedClass, false);
+        multiDragElements[i] === dragEl$1 && toggleClass(multiDragClones[i], this.options.chosenClass, false);
+      }
+      sortable._hideClone();
+      cancel();
+    },
+    clone: function clone2(_ref3) {
+      var sortable = _ref3.sortable, rootEl2 = _ref3.rootEl, dispatchSortableEvent = _ref3.dispatchSortableEvent, cancel = _ref3.cancel;
+      if (!this.isMultiDrag)
+        return;
+      if (!this.options.removeCloneOnHide) {
+        if (multiDragElements.length && multiDragSortable === sortable) {
+          insertMultiDragClones(true, rootEl2);
+          dispatchSortableEvent("clone");
+          cancel();
+        }
+      }
+    },
+    showClone: function showClone(_ref4) {
+      var cloneNowShown = _ref4.cloneNowShown, rootEl2 = _ref4.rootEl, cancel = _ref4.cancel;
+      if (!this.isMultiDrag)
+        return;
+      insertMultiDragClones(false, rootEl2);
+      multiDragClones.forEach(function(clone2) {
+        css(clone2, "display", "");
+      });
+      cloneNowShown();
+      clonesHidden = false;
+      cancel();
+    },
+    hideClone: function hideClone(_ref5) {
+      var _this = this;
+      _ref5.sortable;
+      var cloneNowHidden = _ref5.cloneNowHidden, cancel = _ref5.cancel;
+      if (!this.isMultiDrag)
+        return;
+      multiDragClones.forEach(function(clone2) {
+        css(clone2, "display", "none");
+        if (_this.options.removeCloneOnHide && clone2.parentNode) {
+          clone2.parentNode.removeChild(clone2);
+        }
+      });
+      cloneNowHidden();
+      clonesHidden = true;
+      cancel();
+    },
+    dragStartGlobal: function dragStartGlobal(_ref6) {
+      _ref6.sortable;
+      if (!this.isMultiDrag && multiDragSortable) {
+        multiDragSortable.multiDrag._deselectMultiDrag();
+      }
+      multiDragElements.forEach(function(multiDragElement) {
+        multiDragElement.sortableIndex = index(multiDragElement);
+      });
+      multiDragElements = multiDragElements.sort(function(a, b) {
+        return a.sortableIndex - b.sortableIndex;
+      });
+      dragStarted = true;
+    },
+    dragStarted: function dragStarted2(_ref7) {
+      var _this2 = this;
+      var sortable = _ref7.sortable;
+      if (!this.isMultiDrag)
+        return;
+      if (this.options.sort) {
+        sortable.captureAnimationState();
+        if (this.options.animation) {
+          multiDragElements.forEach(function(multiDragElement) {
+            if (multiDragElement === dragEl$1)
+              return;
+            css(multiDragElement, "position", "absolute");
+          });
+          var dragRect = getRect(dragEl$1, false, true, true);
+          multiDragElements.forEach(function(multiDragElement) {
+            if (multiDragElement === dragEl$1)
+              return;
+            setRect(multiDragElement, dragRect);
+          });
+          folding = true;
+          initialFolding = true;
+        }
+      }
+      sortable.animateAll(function() {
+        folding = false;
+        initialFolding = false;
+        if (_this2.options.animation) {
+          multiDragElements.forEach(function(multiDragElement) {
+            unsetRect(multiDragElement);
+          });
+        }
+        if (_this2.options.sort) {
+          removeMultiDragElements();
+        }
+      });
+    },
+    dragOver: function dragOver(_ref8) {
+      var target = _ref8.target, completed = _ref8.completed, cancel = _ref8.cancel;
+      if (folding && ~multiDragElements.indexOf(target)) {
+        completed(false);
+        cancel();
+      }
+    },
+    revert: function revert(_ref9) {
+      var fromSortable = _ref9.fromSortable, rootEl2 = _ref9.rootEl, sortable = _ref9.sortable, dragRect = _ref9.dragRect;
+      if (multiDragElements.length > 1) {
+        multiDragElements.forEach(function(multiDragElement) {
+          sortable.addAnimationState({
+            target: multiDragElement,
+            rect: folding ? getRect(multiDragElement) : dragRect
+          });
+          unsetRect(multiDragElement);
+          multiDragElement.fromRect = dragRect;
+          fromSortable.removeAnimationState(multiDragElement);
+        });
+        folding = false;
+        insertMultiDragElements(!this.options.removeCloneOnHide, rootEl2);
+      }
+    },
+    dragOverCompleted: function dragOverCompleted(_ref10) {
+      var sortable = _ref10.sortable, isOwner = _ref10.isOwner, insertion = _ref10.insertion, activeSortable = _ref10.activeSortable, parentEl2 = _ref10.parentEl, putSortable2 = _ref10.putSortable;
+      var options = this.options;
+      if (insertion) {
+        if (isOwner) {
+          activeSortable._hideClone();
+        }
+        initialFolding = false;
+        if (options.animation && multiDragElements.length > 1 && (folding || !isOwner && !activeSortable.options.sort && !putSortable2)) {
+          var dragRectAbsolute = getRect(dragEl$1, false, true, true);
+          multiDragElements.forEach(function(multiDragElement) {
+            if (multiDragElement === dragEl$1)
+              return;
+            setRect(multiDragElement, dragRectAbsolute);
+            parentEl2.appendChild(multiDragElement);
+          });
+          folding = true;
+        }
+        if (!isOwner) {
+          if (!folding) {
+            removeMultiDragElements();
+          }
+          if (multiDragElements.length > 1) {
+            var clonesHiddenBefore = clonesHidden;
+            activeSortable._showClone(sortable);
+            if (activeSortable.options.animation && !clonesHidden && clonesHiddenBefore) {
+              multiDragClones.forEach(function(clone2) {
+                activeSortable.addAnimationState({
+                  target: clone2,
+                  rect: clonesFromRect
+                });
+                clone2.fromRect = clonesFromRect;
+                clone2.thisAnimationDuration = null;
+              });
+            }
+          } else {
+            activeSortable._showClone(sortable);
+          }
+        }
+      }
+    },
+    dragOverAnimationCapture: function dragOverAnimationCapture(_ref11) {
+      var dragRect = _ref11.dragRect, isOwner = _ref11.isOwner, activeSortable = _ref11.activeSortable;
+      multiDragElements.forEach(function(multiDragElement) {
+        multiDragElement.thisAnimationDuration = null;
+      });
+      if (activeSortable.options.animation && !isOwner && activeSortable.multiDrag.isMultiDrag) {
+        clonesFromRect = _extends({}, dragRect);
+        var dragMatrix = matrix(dragEl$1, true);
+        clonesFromRect.top -= dragMatrix.f;
+        clonesFromRect.left -= dragMatrix.e;
+      }
+    },
+    dragOverAnimationComplete: function dragOverAnimationComplete() {
+      if (folding) {
+        folding = false;
+        removeMultiDragElements();
+      }
+    },
+    drop: function drop3(_ref12) {
+      var evt = _ref12.originalEvent, rootEl2 = _ref12.rootEl, parentEl2 = _ref12.parentEl, sortable = _ref12.sortable, dispatchSortableEvent = _ref12.dispatchSortableEvent, oldIndex2 = _ref12.oldIndex, putSortable2 = _ref12.putSortable;
+      var toSortable = putSortable2 || this.sortable;
+      if (!evt)
+        return;
+      var options = this.options, children = parentEl2.children;
+      if (!dragStarted) {
+        if (options.multiDragKey && !this.multiDragKeyDown) {
+          this._deselectMultiDrag();
+        }
+        toggleClass(dragEl$1, options.selectedClass, !~multiDragElements.indexOf(dragEl$1));
+        if (!~multiDragElements.indexOf(dragEl$1)) {
+          multiDragElements.push(dragEl$1);
+          dispatchEvent({
+            sortable,
+            rootEl: rootEl2,
+            name: "select",
+            targetEl: dragEl$1,
+            originalEvt: evt
+          });
+          if (evt.shiftKey && lastMultiDragSelect && sortable.el.contains(lastMultiDragSelect)) {
+            var lastIndex = index(lastMultiDragSelect), currentIndex = index(dragEl$1);
+            if (~lastIndex && ~currentIndex && lastIndex !== currentIndex) {
+              var n, i;
+              if (currentIndex > lastIndex) {
+                i = lastIndex;
+                n = currentIndex;
+              } else {
+                i = currentIndex;
+                n = lastIndex + 1;
+              }
+              for (; i < n; i++) {
+                if (~multiDragElements.indexOf(children[i]))
+                  continue;
+                toggleClass(children[i], options.selectedClass, true);
+                multiDragElements.push(children[i]);
+                dispatchEvent({
+                  sortable,
+                  rootEl: rootEl2,
+                  name: "select",
+                  targetEl: children[i],
+                  originalEvt: evt
+                });
+              }
+            }
+          } else {
+            lastMultiDragSelect = dragEl$1;
+          }
+          multiDragSortable = toSortable;
+        } else {
+          multiDragElements.splice(multiDragElements.indexOf(dragEl$1), 1);
+          lastMultiDragSelect = null;
+          dispatchEvent({
+            sortable,
+            rootEl: rootEl2,
+            name: "deselect",
+            targetEl: dragEl$1,
+            originalEvt: evt
+          });
+        }
+      }
+      if (dragStarted && this.isMultiDrag) {
+        folding = false;
+        if ((parentEl2[expando].options.sort || parentEl2 !== rootEl2) && multiDragElements.length > 1) {
+          var dragRect = getRect(dragEl$1), multiDragIndex = index(dragEl$1, ":not(." + this.options.selectedClass + ")");
+          if (!initialFolding && options.animation)
+            dragEl$1.thisAnimationDuration = null;
+          toSortable.captureAnimationState();
+          if (!initialFolding) {
+            if (options.animation) {
+              dragEl$1.fromRect = dragRect;
+              multiDragElements.forEach(function(multiDragElement) {
+                multiDragElement.thisAnimationDuration = null;
+                if (multiDragElement !== dragEl$1) {
+                  var rect = folding ? getRect(multiDragElement) : dragRect;
+                  multiDragElement.fromRect = rect;
+                  toSortable.addAnimationState({
+                    target: multiDragElement,
+                    rect
+                  });
+                }
+              });
+            }
+            removeMultiDragElements();
+            multiDragElements.forEach(function(multiDragElement) {
+              if (children[multiDragIndex]) {
+                parentEl2.insertBefore(multiDragElement, children[multiDragIndex]);
+              } else {
+                parentEl2.appendChild(multiDragElement);
+              }
+              multiDragIndex++;
+            });
+            if (oldIndex2 === index(dragEl$1)) {
+              var update = false;
+              multiDragElements.forEach(function(multiDragElement) {
+                if (multiDragElement.sortableIndex !== index(multiDragElement)) {
+                  update = true;
+                  return;
+                }
+              });
+              if (update) {
+                dispatchSortableEvent("update");
+              }
+            }
+          }
+          multiDragElements.forEach(function(multiDragElement) {
+            unsetRect(multiDragElement);
+          });
+          toSortable.animateAll();
+        }
+        multiDragSortable = toSortable;
+      }
+      if (rootEl2 === parentEl2 || putSortable2 && putSortable2.lastPutMode !== "clone") {
+        multiDragClones.forEach(function(clone2) {
+          clone2.parentNode && clone2.parentNode.removeChild(clone2);
+        });
+      }
+    },
+    nullingGlobal: function nullingGlobal() {
+      this.isMultiDrag = dragStarted = false;
+      multiDragClones.length = 0;
+    },
+    destroyGlobal: function destroyGlobal() {
+      this._deselectMultiDrag();
+      off(document, "pointerup", this._deselectMultiDrag);
+      off(document, "mouseup", this._deselectMultiDrag);
+      off(document, "touchend", this._deselectMultiDrag);
+      off(document, "keydown", this._checkKeyDown);
+      off(document, "keyup", this._checkKeyUp);
+    },
+    _deselectMultiDrag: function _deselectMultiDrag(evt) {
+      if (typeof dragStarted !== "undefined" && dragStarted)
+        return;
+      if (multiDragSortable !== this.sortable)
+        return;
+      if (evt && closest(evt.target, this.options.draggable, this.sortable.el, false))
+        return;
+      if (evt && evt.button !== 0)
+        return;
+      while (multiDragElements.length) {
+        var el = multiDragElements[0];
+        toggleClass(el, this.options.selectedClass, false);
+        multiDragElements.shift();
+        dispatchEvent({
+          sortable: this.sortable,
+          rootEl: this.sortable.el,
+          name: "deselect",
+          targetEl: el,
+          originalEvt: evt
+        });
+      }
+    },
+    _checkKeyDown: function _checkKeyDown(evt) {
+      if (evt.key === this.options.multiDragKey) {
+        this.multiDragKeyDown = true;
+      }
+    },
+    _checkKeyUp: function _checkKeyUp(evt) {
+      if (evt.key === this.options.multiDragKey) {
+        this.multiDragKeyDown = false;
+      }
+    }
+  };
+  return _extends(MultiDrag, {
+    pluginName: "multiDrag",
+    utils: {
+      select: function select(el) {
+        var sortable = el.parentNode[expando];
+        if (!sortable || !sortable.options.multiDrag || ~multiDragElements.indexOf(el))
+          return;
+        if (multiDragSortable && multiDragSortable !== sortable) {
+          multiDragSortable.multiDrag._deselectMultiDrag();
+          multiDragSortable = sortable;
+        }
+        toggleClass(el, sortable.options.selectedClass, true);
+        multiDragElements.push(el);
+      },
+      deselect: function deselect(el) {
+        var sortable = el.parentNode[expando], index2 = multiDragElements.indexOf(el);
+        if (!sortable || !sortable.options.multiDrag || !~index2)
+          return;
+        toggleClass(el, sortable.options.selectedClass, false);
+        multiDragElements.splice(index2, 1);
+      }
+    },
+    eventProperties: function eventProperties() {
+      var _this3 = this;
+      var oldIndicies = [], newIndicies = [];
+      multiDragElements.forEach(function(multiDragElement) {
+        oldIndicies.push({
+          multiDragElement,
+          index: multiDragElement.sortableIndex
+        });
+        var newIndex2;
+        if (folding && multiDragElement !== dragEl$1) {
+          newIndex2 = -1;
+        } else if (folding) {
+          newIndex2 = index(multiDragElement, ":not(." + _this3.options.selectedClass + ")");
+        } else {
+          newIndex2 = index(multiDragElement);
+        }
+        newIndicies.push({
+          multiDragElement,
+          index: newIndex2
+        });
+      });
+      return {
+        items: _toConsumableArray(multiDragElements),
+        clones: [].concat(multiDragClones),
+        oldIndicies,
+        newIndicies
+      };
+    },
+    optionListeners: {
+      multiDragKey: function multiDragKey(key) {
+        key = key.toLowerCase();
+        if (key === "ctrl") {
+          key = "Control";
+        } else if (key.length > 1) {
+          key = key.charAt(0).toUpperCase() + key.substr(1);
+        }
+        return key;
+      }
+    }
+  });
+}
+function insertMultiDragElements(clonesInserted, rootEl2) {
+  multiDragElements.forEach(function(multiDragElement, i) {
+    var target = rootEl2.children[multiDragElement.sortableIndex + (clonesInserted ? Number(i) : 0)];
+    if (target) {
+      rootEl2.insertBefore(multiDragElement, target);
+    } else {
+      rootEl2.appendChild(multiDragElement);
+    }
+  });
+}
+function insertMultiDragClones(elementsInserted, rootEl2) {
+  multiDragClones.forEach(function(clone2, i) {
+    var target = rootEl2.children[clone2.sortableIndex + (elementsInserted ? Number(i) : 0)];
+    if (target) {
+      rootEl2.insertBefore(clone2, target);
+    } else {
+      rootEl2.appendChild(clone2);
+    }
+  });
+}
+function removeMultiDragElements() {
+  multiDragElements.forEach(function(multiDragElement) {
+    if (multiDragElement === dragEl$1)
+      return;
+    multiDragElement.parentNode && multiDragElement.parentNode.removeChild(multiDragElement);
+  });
+}
 Sortable.mount(new AutoScrollPlugin());
 Sortable.mount(Remove, Revert);
+var sortable_esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  "default": Sortable,
+  MultiDrag: MultiDragPlugin,
+  Sortable,
+  Swap: SwapPlugin
+}, Symbol.toStringTag, { value: "Module" }));
 (function(module, exports) {
   (function webpackUniversalModuleDefinition(root, factory) {
-    module.exports = factory(require$$0$1, Sortable);
+    module.exports = factory(require$$0, sortable_esm);
   })(typeof self !== "undefined" ? self : commonjsGlobal, function(__WEBPACK_EXTERNAL_MODULE__8bbf__, __WEBPACK_EXTERNAL_MODULE_a352__) {
     return function(modules2) {
       var installedModules = {};
@@ -62247,7 +62863,7 @@ Sortable.mount(Remove, Revert);
         __webpack_require__("fb6a");
         __webpack_require__("b0c0");
         __webpack_require__("25f0");
-        function _arrayLikeToArray(arr, len) {
+        function _arrayLikeToArray2(arr, len) {
           if (len == null || len > arr.length)
             len = arr.length;
           for (var i = 0, arr2 = new Array(len); i < len; i++) {
@@ -62255,38 +62871,38 @@ Sortable.mount(Remove, Revert);
           }
           return arr2;
         }
-        function _unsupportedIterableToArray(o, minLen) {
+        function _unsupportedIterableToArray2(o, minLen) {
           if (!o)
             return;
           if (typeof o === "string")
-            return _arrayLikeToArray(o, minLen);
+            return _arrayLikeToArray2(o, minLen);
           var n = Object.prototype.toString.call(o).slice(8, -1);
           if (n === "Object" && o.constructor)
             n = o.constructor.name;
           if (n === "Map" || n === "Set")
             return Array.from(o);
           if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-            return _arrayLikeToArray(o, minLen);
+            return _arrayLikeToArray2(o, minLen);
         }
         function _nonIterableRest() {
           throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
         }
         function _slicedToArray(arr, i) {
-          return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+          return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray2(arr, i) || _nonIterableRest();
         }
-        function _arrayWithoutHoles(arr) {
+        function _arrayWithoutHoles2(arr) {
           if (Array.isArray(arr))
-            return _arrayLikeToArray(arr);
+            return _arrayLikeToArray2(arr);
         }
-        function _iterableToArray(iter) {
+        function _iterableToArray2(iter) {
           if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
             return Array.from(iter);
         }
-        function _nonIterableSpread() {
+        function _nonIterableSpread2() {
           throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
         }
-        function _toConsumableArray(arr) {
-          return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+        function _toConsumableArray2(arr) {
+          return _arrayWithoutHoles2(arr) || _iterableToArray2(arr) || _unsupportedIterableToArray2(arr) || _nonIterableSpread2();
         }
         var external_commonjs_sortablejs_commonjs2_sortablejs_amd_sortablejs_root_Sortable_ = __webpack_require__("a352");
         var external_commonjs_sortablejs_commonjs2_sortablejs_amd_sortablejs_root_Sortable_default = /* @__PURE__ */ __webpack_require__.n(external_commonjs_sortablejs_commonjs2_sortablejs_amd_sortablejs_root_Sortable_);
@@ -62432,7 +63048,7 @@ Sortable.mount(Remove, Revert);
             var _ref$nodes = _ref.nodes, header = _ref$nodes.header, defaultNodes = _ref$nodes.default, footer = _ref$nodes.footer, root = _ref.root, realList = _ref.realList;
             _classCallCheck(this, ComponentStructure);
             this.defaultNodes = defaultNodes;
-            this.children = [].concat(_toConsumableArray(header), _toConsumableArray(defaultNodes), _toConsumableArray(footer));
+            this.children = [].concat(_toConsumableArray2(header), _toConsumableArray2(defaultNodes), _toConsumableArray2(footer));
             this.externalComponent = root.externalComponent;
             this.rootTransition = root.transition;
             this.tag = root.tag;
@@ -62483,7 +63099,7 @@ Sortable.mount(Remove, Revert);
                 return 0;
               }
               var firstDomListElement = getHtmlElementFromNode(defaultNodes[0]);
-              var indexFirstDomListElement = _toConsumableArray(domChildren).findIndex(function(element2) {
+              var indexFirstDomListElement = _toConsumableArray2(domChildren).findIndex(function(element2) {
                 return element2 === firstDomListElement;
               });
               return domIndex < indexFirstDomListElement ? 0 : length;
@@ -62613,7 +63229,7 @@ Sortable.mount(Remove, Revert);
             default: null
           }
         };
-        var emits = ["update:modelValue", "change"].concat(_toConsumableArray([].concat(_toConsumableArray(events.manageAndEmit), _toConsumableArray(events.emit)).map(function(evt) {
+        var emits = ["update:modelValue", "change"].concat(_toConsumableArray2([].concat(_toConsumableArray2(events.manageAndEmit), _toConsumableArray2(events.emit)).map(function(evt) {
           return evt.toLowerCase();
         })));
         var draggableComponent = Object(external_commonjs_vue_commonjs2_vue_root_Vue_["defineComponent"])({
@@ -62736,14 +63352,14 @@ Sortable.mount(Remove, Revert);
                 onList(this.list);
                 return;
               }
-              var newList = _toConsumableArray(this.modelValue);
+              var newList = _toConsumableArray2(this.modelValue);
               onList(newList);
               this.$emit("update:modelValue", newList);
             },
             spliceList: function spliceList() {
               var _arguments = arguments;
               var spliceList2 = function spliceList3(list) {
-                return list.splice.apply(list, _toConsumableArray(_arguments));
+                return list.splice.apply(list, _toConsumableArray2(_arguments));
               };
               this.alterList(spliceList2);
             },
@@ -62831,7 +63447,7 @@ Sortable.mount(Remove, Revert);
               if (!relatedContext.element) {
                 return 0;
               }
-              var domChildren = _toConsumableArray(evt.to.children).filter(function(el) {
+              var domChildren = _toConsumableArray2(evt.to.children).filter(function(el) {
                 return el.style["display"] !== "none";
               });
               var currentDomIndex = domChildren.indexOf(evt.related);
@@ -62957,7 +63573,7 @@ Sortable.mount(Remove, Revert);
     })["default"];
   });
 })(vuedraggable_umd);
-var Draggable = /* @__PURE__ */ getDefaultExportFromCjs(vuedraggable_umd.exports);
+var VuedraggableCjs = /* @__PURE__ */ getDefaultExportFromCjs(vuedraggable_umd.exports);
 var _export_sfc = (sfc, props) => {
   const target = sfc.__vccOpts || sfc;
   for (const [key, val] of props) {
@@ -63183,13 +63799,13 @@ function registerIcon(app) {
 if (typeof window !== "undefined") {
   let loadSvg = function() {
     var body = document.body;
-    var svgDom = document.getElementById("__svg__icons__dom__1762584380167__");
+    var svgDom = document.getElementById("__svg__icons__dom__1762585211641__");
     if (!svgDom) {
       svgDom = document.createElementNS("http://www.w3.org/2000/svg", "svg");
       svgDom.style.position = "absolute";
       svgDom.style.width = "0";
       svgDom.style.height = "0";
-      svgDom.id = "__svg__icons__dom__1762584380167__";
+      svgDom.id = "__svg__icons__dom__1762585211641__";
       svgDom.setAttribute("xmlns", "http://www.w3.org/2000/svg");
       svgDom.setAttribute("xmlns:link", "http://www.w3.org/1999/xlink");
     }
@@ -63858,6 +64474,7 @@ const loadExtension = function(app) {
   registerEPEditor(app, "alert-onClose", "alert-onClose-editor", createEventHandlerEditor("onClose", []));
   registerFWGenerator("alert", alertTemplateGenerator);
 };
+const Draggable = (_a = VuedraggableCjs == null ? void 0 : VuedraggableCjs.default) != null ? _a : VuedraggableCjs;
 VFormDesigner.install = function(app) {
   addDirective(app);
   loadExtension(app);