linkmore-design 1.0.38 → 1.0.39

package/dist/index.umd.js

@@ -2238,6 +2238,19 @@
 	LoadingOutlined$1.displayName = 'LoadingOutlined';
 	var LoadingOutlined$2 = /*#__PURE__*/React.forwardRef(LoadingOutlined$1);
 
+	// This icon file is generated automatically.
+	var MenuOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M904 160H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8zm0 624H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8zm0-312H120c-4.4 0-8 3.6-8 8v64c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-64c0-4.4-3.6-8-8-8z" } }] }, "name": "menu", "theme": "outlined" };
+
+	var MenuOutlined$1 = function MenuOutlined$1(props, ref) {
+	  return /*#__PURE__*/React.createElement(Icon, _objectSpread2(_objectSpread2({}, props), {}, {
+	    ref: ref,
+	    icon: MenuOutlined
+	  }));
+	};
+
+	MenuOutlined$1.displayName = 'MenuOutlined';
+	var MenuOutlined$2 = /*#__PURE__*/React.forwardRef(MenuOutlined$1);
+
 	// This icon file is generated automatically.
 	var MessageOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M464 512a48 48 0 1096 0 48 48 0 10-96 0zm200 0a48 48 0 1096 0 48 48 0 10-96 0zm-400 0a48 48 0 1096 0 48 48 0 10-96 0zm661.2-173.6c-22.6-53.7-55-101.9-96.3-143.3a444.35 444.35 0 00-143.3-96.3C630.6 75.7 572.2 64 512 64h-2c-60.6.3-119.3 12.3-174.5 35.9a445.35 445.35 0 00-142 96.5c-40.9 41.3-73 89.3-95.2 142.8-23 55.4-34.6 114.3-34.3 174.9A449.4 449.4 0 00112 714v152a46 46 0 0046 46h152.1A449.4 449.4 0 00510 960h2.1c59.9 0 118-11.6 172.7-34.3a444.48 444.48 0 00142.8-95.2c41.3-40.9 73.8-88.7 96.5-142 23.6-55.2 35.6-113.9 35.9-174.5.3-60.9-11.5-120-34.8-175.6zm-151.1 438C704 845.8 611 884 512 884h-1.7c-60.3-.3-120.2-15.3-173.1-43.5l-8.4-4.5H188V695.2l-4.5-8.4C155.3 633.9 140.3 574 140 513.7c-.4-99.7 37.7-193.3 107.6-263.8 69.8-70.5 163.1-109.5 262.8-109.9h1.7c50 0 98.5 9.7 144.2 28.9 44.6 18.7 84.6 45.6 119 80 34.3 34.3 61.3 74.4 80 119 19.4 46.2 29.1 95.2 28.9 145.8-.6 99.6-39.7 192.9-110.1 262.7z" } }] }, "name": "message", "theme": "outlined" };
 
@@ -56776,6 +56789,62 @@
 	  return _extends$5.apply(this, arguments);
 	}
 
+	function _objectSpread$7(target) {
+	  for (var i = 1; i < arguments.length; i++) {
+	    var source = arguments[i] != null ? Object(arguments[i]) : {};
+	    var ownKeys = Object.keys(source);
+
+	    if (typeof Object.getOwnPropertySymbols === 'function') {
+	      ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
+	        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+	      }));
+	    }
+
+	    ownKeys.forEach(function (key) {
+	      _defineProperty$1(target, key, source[key]);
+	    });
+	  }
+
+	  return target;
+	}
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 *
+	 * This source code is licensed under the MIT license found in the
+	 * LICENSE file in the root directory of this source tree.
+	 */
+
+	var invariant = function(condition, format, a, b, c, d, e, f) {
+	  {
+	    if (format === undefined) {
+	      throw new Error('invariant requires an error message argument');
+	    }
+	  }
+
+	  if (!condition) {
+	    var error;
+	    if (format === undefined) {
+	      error = new Error(
+	        'Minified exception occurred; use the non-minified dev environment ' +
+	        'for the full error message and additional helpful warnings.'
+	      );
+	    } else {
+	      var args = [a, b, c, d, e, f];
+	      var argIndex = 0;
+	      error = new Error(
+	        format.replace(/%s/g, function() { return args[argIndex++]; })
+	      );
+	      error.name = 'Invariant Violation';
+	    }
+
+	    error.framesToPop = 1; // we don't care about invariant's own frame
+	    throw error;
+	  }
+	};
+
+	var invariant_1 = invariant;
+
 	var reactIs_development = createCommonjsModule(function (module, exports) {
 
 
@@ -57766,6 +57835,1583 @@
 	}
 	});
 
+	var Manager = function () {
+	  function Manager() {
+	    _classCallCheck(this, Manager);
+
+	    _defineProperty$1(this, "refs", {});
+	  }
+
+	  _createClass(Manager, [{
+	    key: "add",
+	    value: function add(collection, ref) {
+	      if (!this.refs[collection]) {
+	        this.refs[collection] = [];
+	      }
+
+	      this.refs[collection].push(ref);
+	    }
+	  }, {
+	    key: "remove",
+	    value: function remove(collection, ref) {
+	      var index = this.getIndex(collection, ref);
+
+	      if (index !== -1) {
+	        this.refs[collection].splice(index, 1);
+	      }
+	    }
+	  }, {
+	    key: "isActive",
+	    value: function isActive() {
+	      return this.active;
+	    }
+	  }, {
+	    key: "getActive",
+	    value: function getActive() {
+	      var _this = this;
+
+	      return this.refs[this.active.collection].find(function (_ref) {
+	        var node = _ref.node;
+	        return node.sortableInfo.index == _this.active.index;
+	      });
+	    }
+	  }, {
+	    key: "getIndex",
+	    value: function getIndex(collection, ref) {
+	      return this.refs[collection].indexOf(ref);
+	    }
+	  }, {
+	    key: "getOrderedRefs",
+	    value: function getOrderedRefs() {
+	      var collection = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.active.collection;
+	      return this.refs[collection].sort(sortByIndex);
+	    }
+	  }]);
+
+	  return Manager;
+	}();
+
+	function sortByIndex(_ref2, _ref3) {
+	  var index1 = _ref2.node.sortableInfo.index;
+	  var index2 = _ref3.node.sortableInfo.index;
+	  return index1 - index2;
+	}
+	function omit$1(obj, keysToOmit) {
+	  return Object.keys(obj).reduce(function (acc, key) {
+	    if (keysToOmit.indexOf(key) === -1) {
+	      acc[key] = obj[key];
+	    }
+
+	    return acc;
+	  }, {});
+	}
+	var events$1 = {
+	  end: ['touchend', 'touchcancel', 'mouseup'],
+	  move: ['touchmove', 'mousemove'],
+	  start: ['touchstart', 'mousedown']
+	};
+	var vendorPrefix = function () {
+	  if (typeof window === 'undefined' || typeof document === 'undefined') {
+	    return '';
+	  }
+
+	  var styles = window.getComputedStyle(document.documentElement, '') || ['-moz-hidden-iframe'];
+	  var pre = (Array.prototype.slice.call(styles).join('').match(/-(moz|webkit|ms)-/) || styles.OLink === '' && ['', 'o'])[1];
+
+	  switch (pre) {
+	    case 'ms':
+	      return 'ms';
+
+	    default:
+	      return pre && pre.length ? pre[0].toUpperCase() + pre.substr(1) : '';
+	  }
+	}();
+	function setInlineStyles(node, styles) {
+	  Object.keys(styles).forEach(function (key) {
+	    node.style[key] = styles[key];
+	  });
+	}
+	function setTranslate3d(node, translate) {
+	  node.style["".concat(vendorPrefix, "Transform")] = translate == null ? '' : "translate3d(".concat(translate.x, "px,").concat(translate.y, "px,0)");
+	}
+	function setTransitionDuration(node, duration) {
+	  node.style["".concat(vendorPrefix, "TransitionDuration")] = duration == null ? '' : "".concat(duration, "ms");
+	}
+	function closest(el, fn) {
+	  while (el) {
+	    if (fn(el)) {
+	      return el;
+	    }
+
+	    el = el.parentNode;
+	  }
+
+	  return null;
+	}
+	function limit(min, max, value) {
+	  return Math.max(min, Math.min(value, max));
+	}
+
+	function getPixelValue(stringValue) {
+	  if (stringValue.substr(-2) === 'px') {
+	    return parseFloat(stringValue);
+	  }
+
+	  return 0;
+	}
+
+	function getElementMargin(element) {
+	  var style = window.getComputedStyle(element);
+	  return {
+	    bottom: getPixelValue(style.marginBottom),
+	    left: getPixelValue(style.marginLeft),
+	    right: getPixelValue(style.marginRight),
+	    top: getPixelValue(style.marginTop)
+	  };
+	}
+	function provideDisplayName(prefix, Component$$1) {
+	  var componentName = Component$$1.displayName || Component$$1.name;
+	  return componentName ? "".concat(prefix, "(").concat(componentName, ")") : prefix;
+	}
+	function getScrollAdjustedBoundingClientRect(node, scrollDelta) {
+	  var boundingClientRect = node.getBoundingClientRect();
+	  return {
+	    top: boundingClientRect.top + scrollDelta.top,
+	    left: boundingClientRect.left + scrollDelta.left
+	  };
+	}
+	function getPosition(event) {
+	  if (event.touches && event.touches.length) {
+	    return {
+	      x: event.touches[0].pageX,
+	      y: event.touches[0].pageY
+	    };
+	  } else if (event.changedTouches && event.changedTouches.length) {
+	    return {
+	      x: event.changedTouches[0].pageX,
+	      y: event.changedTouches[0].pageY
+	    };
+	  } else {
+	    return {
+	      x: event.pageX,
+	      y: event.pageY
+	    };
+	  }
+	}
+	function isTouchEvent$1(event) {
+	  return event.touches && event.touches.length || event.changedTouches && event.changedTouches.length;
+	}
+	function getEdgeOffset(node, parent) {
+	  var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+	    left: 0,
+	    top: 0
+	  };
+
+	  if (!node) {
+	    return undefined;
+	  }
+
+	  var nodeOffset = {
+	    left: offset.left + node.offsetLeft,
+	    top: offset.top + node.offsetTop
+	  };
+
+	  if (node.parentNode === parent) {
+	    return nodeOffset;
+	  }
+
+	  return getEdgeOffset(node.parentNode, parent, nodeOffset);
+	}
+	function getTargetIndex(newIndex, prevIndex, oldIndex) {
+	  if (newIndex < oldIndex && newIndex > prevIndex) {
+	    return newIndex - 1;
+	  } else if (newIndex > oldIndex && newIndex < prevIndex) {
+	    return newIndex + 1;
+	  } else {
+	    return newIndex;
+	  }
+	}
+	function getLockPixelOffset(_ref) {
+	  var lockOffset = _ref.lockOffset,
+	      width = _ref.width,
+	      height = _ref.height;
+	  var offsetX = lockOffset;
+	  var offsetY = lockOffset;
+	  var unit = 'px';
+
+	  if (typeof lockOffset === 'string') {
+	    var match = /^[+-]?\d*(?:\.\d*)?(px|%)$/.exec(lockOffset);
+	    invariant_1(match !== null, 'lockOffset value should be a number or a string of a ' + 'number followed by "px" or "%". Given %s', lockOffset);
+	    offsetX = parseFloat(lockOffset);
+	    offsetY = parseFloat(lockOffset);
+	    unit = match[1];
+	  }
+
+	  invariant_1(isFinite(offsetX) && isFinite(offsetY), 'lockOffset value should be a finite. Given %s', lockOffset);
+
+	  if (unit === '%') {
+	    offsetX = offsetX * width / 100;
+	    offsetY = offsetY * height / 100;
+	  }
+
+	  return {
+	    x: offsetX,
+	    y: offsetY
+	  };
+	}
+	function getLockPixelOffsets(_ref2) {
+	  var height = _ref2.height,
+	      width = _ref2.width,
+	      lockOffset = _ref2.lockOffset;
+	  var offsets = Array.isArray(lockOffset) ? lockOffset : [lockOffset, lockOffset];
+	  invariant_1(offsets.length === 2, 'lockOffset prop of SortableContainer should be a single ' + 'value or an array of exactly two values. Given %s', lockOffset);
+
+	  var _offsets = _slicedToArray$1(offsets, 2),
+	      minLockOffset = _offsets[0],
+	      maxLockOffset = _offsets[1];
+
+	  return [getLockPixelOffset({
+	    height: height,
+	    lockOffset: minLockOffset,
+	    width: width
+	  }), getLockPixelOffset({
+	    height: height,
+	    lockOffset: maxLockOffset,
+	    width: width
+	  })];
+	}
+
+	function isScrollable$1(el) {
+	  var computedStyle = window.getComputedStyle(el);
+	  var overflowRegex = /(auto|scroll)/;
+	  var properties = ['overflow', 'overflowX', 'overflowY'];
+	  return properties.find(function (property) {
+	    return overflowRegex.test(computedStyle[property]);
+	  });
+	}
+
+	function getScrollingParent(el) {
+	  if (!(el instanceof HTMLElement)) {
+	    return null;
+	  } else if (isScrollable$1(el)) {
+	    return el;
+	  } else {
+	    return getScrollingParent(el.parentNode);
+	  }
+	}
+	function getContainerGridGap(element) {
+	  var style = window.getComputedStyle(element);
+
+	  if (style.display === 'grid') {
+	    return {
+	      x: getPixelValue(style.gridColumnGap),
+	      y: getPixelValue(style.gridRowGap)
+	    };
+	  }
+
+	  return {
+	    x: 0,
+	    y: 0
+	  };
+	}
+	var KEYCODE = {
+	  TAB: 9,
+	  ESC: 27,
+	  SPACE: 32,
+	  LEFT: 37,
+	  UP: 38,
+	  RIGHT: 39,
+	  DOWN: 40
+	};
+	var NodeType = {
+	  Anchor: 'A',
+	  Button: 'BUTTON',
+	  Canvas: 'CANVAS',
+	  Input: 'INPUT',
+	  Option: 'OPTION',
+	  Textarea: 'TEXTAREA',
+	  Select: 'SELECT'
+	};
+	function cloneNode(node) {
+	  var selector = 'input, textarea, select, canvas, [contenteditable]';
+	  var fields = node.querySelectorAll(selector);
+	  var clonedNode = node.cloneNode(true);
+
+	  var clonedFields = _toConsumableArray$1(clonedNode.querySelectorAll(selector));
+
+	  clonedFields.forEach(function (field, i) {
+	    if (field.type !== 'file') {
+	      field.value = fields[i].value;
+	    }
+
+	    if (field.type === 'radio' && field.name) {
+	      field.name = "__sortableClone__".concat(field.name);
+	    }
+
+	    if (field.tagName === NodeType.Canvas && fields[i].width > 0 && fields[i].height > 0) {
+	      var destCtx = field.getContext('2d');
+	      destCtx.drawImage(fields[i], 0, 0);
+	    }
+	  });
+	  return clonedNode;
+	}
+
+	function sortableHandle(WrappedComponent) {
+	  var _class, _temp;
+
+	  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+	    withRef: false
+	  };
+	  return _temp = _class = function (_React$Component) {
+	    _inherits(WithSortableHandle, _React$Component);
+
+	    function WithSortableHandle() {
+	      var _getPrototypeOf2;
+
+	      var _this;
+
+	      _classCallCheck(this, WithSortableHandle);
+
+	      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+	        args[_key] = arguments[_key];
+	      }
+
+	      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WithSortableHandle)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "wrappedInstance", React.createRef());
+
+	      return _this;
+	    }
+
+	    _createClass(WithSortableHandle, [{
+	      key: "componentDidMount",
+	      value: function componentDidMount() {
+	        var node = require$$2.findDOMNode(this);
+	        node.sortableHandle = true;
+	      }
+	    }, {
+	      key: "getWrappedInstance",
+	      value: function getWrappedInstance() {
+	        invariant_1(config.withRef, 'To access the wrapped instance, you need to pass in {withRef: true} as the second argument of the SortableHandle() call');
+	        return this.wrappedInstance.current;
+	      }
+	    }, {
+	      key: "render",
+	      value: function render() {
+	        var ref = config.withRef ? this.wrappedInstance : null;
+	        return React.createElement(WrappedComponent, _extends$5({
+	          ref: ref
+	        }, this.props));
+	      }
+	    }]);
+
+	    return WithSortableHandle;
+	  }(React.Component), _defineProperty$1(_class, "displayName", provideDisplayName('sortableHandle', WrappedComponent)), _temp;
+	}
+	function isSortableHandle(node) {
+	  return node.sortableHandle != null;
+	}
+
+	var AutoScroller = function () {
+	  function AutoScroller(container, onScrollCallback) {
+	    _classCallCheck(this, AutoScroller);
+
+	    this.container = container;
+	    this.onScrollCallback = onScrollCallback;
+	  }
+
+	  _createClass(AutoScroller, [{
+	    key: "clear",
+	    value: function clear() {
+	      if (this.interval == null) {
+	        return;
+	      }
+
+	      clearInterval(this.interval);
+	      this.interval = null;
+	    }
+	  }, {
+	    key: "update",
+	    value: function update(_ref) {
+	      var _this = this;
+
+	      var translate = _ref.translate,
+	          minTranslate = _ref.minTranslate,
+	          maxTranslate = _ref.maxTranslate,
+	          width = _ref.width,
+	          height = _ref.height;
+	      var direction = {
+	        x: 0,
+	        y: 0
+	      };
+	      var speed = {
+	        x: 1,
+	        y: 1
+	      };
+	      var acceleration = {
+	        x: 10,
+	        y: 10
+	      };
+	      var _this$container = this.container,
+	          scrollTop = _this$container.scrollTop,
+	          scrollLeft = _this$container.scrollLeft,
+	          scrollHeight = _this$container.scrollHeight,
+	          scrollWidth = _this$container.scrollWidth,
+	          clientHeight = _this$container.clientHeight,
+	          clientWidth = _this$container.clientWidth;
+	      var isTop = scrollTop === 0;
+	      var isBottom = scrollHeight - scrollTop - clientHeight === 0;
+	      var isLeft = scrollLeft === 0;
+	      var isRight = scrollWidth - scrollLeft - clientWidth === 0;
+
+	      if (translate.y >= maxTranslate.y - height / 2 && !isBottom) {
+	        direction.y = 1;
+	        speed.y = acceleration.y * Math.abs((maxTranslate.y - height / 2 - translate.y) / height);
+	      } else if (translate.x >= maxTranslate.x - width / 2 && !isRight) {
+	        direction.x = 1;
+	        speed.x = acceleration.x * Math.abs((maxTranslate.x - width / 2 - translate.x) / width);
+	      } else if (translate.y <= minTranslate.y + height / 2 && !isTop) {
+	        direction.y = -1;
+	        speed.y = acceleration.y * Math.abs((translate.y - height / 2 - minTranslate.y) / height);
+	      } else if (translate.x <= minTranslate.x + width / 2 && !isLeft) {
+	        direction.x = -1;
+	        speed.x = acceleration.x * Math.abs((translate.x - width / 2 - minTranslate.x) / width);
+	      }
+
+	      if (this.interval) {
+	        this.clear();
+	        this.isAutoScrolling = false;
+	      }
+
+	      if (direction.x !== 0 || direction.y !== 0) {
+	        this.interval = setInterval(function () {
+	          _this.isAutoScrolling = true;
+	          var offset = {
+	            left: speed.x * direction.x,
+	            top: speed.y * direction.y
+	          };
+	          _this.container.scrollTop += offset.top;
+	          _this.container.scrollLeft += offset.left;
+
+	          _this.onScrollCallback(offset);
+	        }, 5);
+	      }
+	    }
+	  }]);
+
+	  return AutoScroller;
+	}();
+
+	function defaultGetHelperDimensions(_ref) {
+	  var node = _ref.node;
+	  return {
+	    height: node.offsetHeight,
+	    width: node.offsetWidth
+	  };
+	}
+
+	function defaultShouldCancelStart(event) {
+	  var interactiveElements = [NodeType.Input, NodeType.Textarea, NodeType.Select, NodeType.Option, NodeType.Button];
+
+	  if (interactiveElements.indexOf(event.target.tagName) !== -1) {
+	    return true;
+	  }
+
+	  if (closest(event.target, function (el) {
+	    return el.contentEditable === 'true';
+	  })) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	var propTypes$1 = {
+	  axis: propTypes.oneOf(['x', 'y', 'xy']),
+	  contentWindow: propTypes.any,
+	  disableAutoscroll: propTypes.bool,
+	  distance: propTypes.number,
+	  getContainer: propTypes.func,
+	  getHelperDimensions: propTypes.func,
+	  helperClass: propTypes.string,
+	  helperContainer: propTypes.oneOfType([propTypes.func, typeof HTMLElement === 'undefined' ? propTypes.any : propTypes.instanceOf(HTMLElement)]),
+	  hideSortableGhost: propTypes.bool,
+	  keyboardSortingTransitionDuration: propTypes.number,
+	  lockAxis: propTypes.string,
+	  lockOffset: propTypes.oneOfType([propTypes.number, propTypes.string, propTypes.arrayOf(propTypes.oneOfType([propTypes.number, propTypes.string]))]),
+	  lockToContainerEdges: propTypes.bool,
+	  onSortEnd: propTypes.func,
+	  onSortMove: propTypes.func,
+	  onSortOver: propTypes.func,
+	  onSortStart: propTypes.func,
+	  pressDelay: propTypes.number,
+	  pressThreshold: propTypes.number,
+	  keyCodes: propTypes.shape({
+	    lift: propTypes.arrayOf(propTypes.number),
+	    drop: propTypes.arrayOf(propTypes.number),
+	    cancel: propTypes.arrayOf(propTypes.number),
+	    up: propTypes.arrayOf(propTypes.number),
+	    down: propTypes.arrayOf(propTypes.number)
+	  }),
+	  shouldCancelStart: propTypes.func,
+	  transitionDuration: propTypes.number,
+	  updateBeforeSortStart: propTypes.func,
+	  useDragHandle: propTypes.bool,
+	  useWindowAsScrollContainer: propTypes.bool
+	};
+	var defaultKeyCodes = {
+	  lift: [KEYCODE.SPACE],
+	  drop: [KEYCODE.SPACE],
+	  cancel: [KEYCODE.ESC],
+	  up: [KEYCODE.UP, KEYCODE.LEFT],
+	  down: [KEYCODE.DOWN, KEYCODE.RIGHT]
+	};
+	var defaultProps = {
+	  axis: 'y',
+	  disableAutoscroll: false,
+	  distance: 0,
+	  getHelperDimensions: defaultGetHelperDimensions,
+	  hideSortableGhost: true,
+	  lockOffset: '50%',
+	  lockToContainerEdges: false,
+	  pressDelay: 0,
+	  pressThreshold: 5,
+	  keyCodes: defaultKeyCodes,
+	  shouldCancelStart: defaultShouldCancelStart,
+	  transitionDuration: 300,
+	  useWindowAsScrollContainer: false
+	};
+	var omittedProps = Object.keys(propTypes$1);
+	function validateProps(props) {
+	  invariant_1(!(props.distance && props.pressDelay), 'Attempted to set both `pressDelay` and `distance` on SortableContainer, you may only use one or the other, not both at the same time.');
+	}
+
+	function _finallyRethrows(body, finalizer) {
+	  try {
+	    var result = body();
+	  } catch (e) {
+	    return finalizer(true, e);
+	  }
+
+	  if (result && result.then) {
+	    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+	  }
+
+	  return finalizer(false, value);
+	}
+	var SortableContext$1 = React.createContext({
+	  manager: {}
+	});
+	function sortableContainer(WrappedComponent) {
+	  var _class, _temp;
+
+	  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+	    withRef: false
+	  };
+	  return _temp = _class = function (_React$Component) {
+	    _inherits(WithSortableContainer, _React$Component);
+
+	    function WithSortableContainer(props) {
+	      var _this;
+
+	      _classCallCheck(this, WithSortableContainer);
+
+	      _this = _possibleConstructorReturn(this, _getPrototypeOf(WithSortableContainer).call(this, props));
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "state", {});
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleStart", function (event) {
+	        var _this$props = _this.props,
+	            distance = _this$props.distance,
+	            shouldCancelStart = _this$props.shouldCancelStart;
+
+	        if (event.button === 2 || shouldCancelStart(event)) {
+	          return;
+	        }
+
+	        _this.touched = true;
+	        _this.position = getPosition(event);
+	        var node = closest(event.target, function (el) {
+	          return el.sortableInfo != null;
+	        });
+
+	        if (node && node.sortableInfo && _this.nodeIsChild(node) && !_this.state.sorting) {
+	          var useDragHandle = _this.props.useDragHandle;
+	          var _node$sortableInfo = node.sortableInfo,
+	              index = _node$sortableInfo.index,
+	              collection = _node$sortableInfo.collection,
+	              disabled = _node$sortableInfo.disabled;
+
+	          if (disabled) {
+	            return;
+	          }
+
+	          if (useDragHandle && !closest(event.target, isSortableHandle)) {
+	            return;
+	          }
+
+	          _this.manager.active = {
+	            collection: collection,
+	            index: index
+	          };
+
+	          if (!isTouchEvent$1(event) && event.target.tagName === NodeType.Anchor) {
+	            event.preventDefault();
+	          }
+
+	          if (!distance) {
+	            if (_this.props.pressDelay === 0) {
+	              _this.handlePress(event);
+	            } else {
+	              _this.pressTimer = setTimeout(function () {
+	                return _this.handlePress(event);
+	              }, _this.props.pressDelay);
+	            }
+	          }
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "nodeIsChild", function (node) {
+	        return node.sortableInfo.manager === _this.manager;
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleMove", function (event) {
+	        var _this$props2 = _this.props,
+	            distance = _this$props2.distance,
+	            pressThreshold = _this$props2.pressThreshold;
+
+	        if (!_this.state.sorting && _this.touched && !_this._awaitingUpdateBeforeSortStart) {
+	          var position = getPosition(event);
+	          var delta = {
+	            x: _this.position.x - position.x,
+	            y: _this.position.y - position.y
+	          };
+	          var combinedDelta = Math.abs(delta.x) + Math.abs(delta.y);
+	          _this.delta = delta;
+
+	          if (!distance && (!pressThreshold || combinedDelta >= pressThreshold)) {
+	            clearTimeout(_this.cancelTimer);
+	            _this.cancelTimer = setTimeout(_this.cancel, 0);
+	          } else if (distance && combinedDelta >= distance && _this.manager.isActive()) {
+	            _this.handlePress(event);
+	          }
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleEnd", function () {
+	        _this.touched = false;
+
+	        _this.cancel();
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "cancel", function () {
+	        var distance = _this.props.distance;
+	        var sorting = _this.state.sorting;
+
+	        if (!sorting) {
+	          if (!distance) {
+	            clearTimeout(_this.pressTimer);
+	          }
+
+	          _this.manager.active = null;
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handlePress", function (event) {
+	        try {
+	          var active = _this.manager.getActive();
+
+	          var _temp6 = function () {
+	            if (active) {
+	              var _temp7 = function _temp7() {
+	                var index = _node.sortableInfo.index;
+	                var margin = getElementMargin(_node);
+	                var gridGap = getContainerGridGap(_this.container);
+
+	                var containerBoundingRect = _this.scrollContainer.getBoundingClientRect();
+
+	                var dimensions = _getHelperDimensions({
+	                  index: index,
+	                  node: _node,
+	                  collection: _collection
+	                });
+
+	                _this.node = _node;
+	                _this.margin = margin;
+	                _this.gridGap = gridGap;
+	                _this.width = dimensions.width;
+	                _this.height = dimensions.height;
+	                _this.marginOffset = {
+	                  x: _this.margin.left + _this.margin.right + _this.gridGap.x,
+	                  y: Math.max(_this.margin.top, _this.margin.bottom, _this.gridGap.y)
+	                };
+	                _this.boundingClientRect = _node.getBoundingClientRect();
+	                _this.containerBoundingRect = containerBoundingRect;
+	                _this.index = index;
+	                _this.newIndex = index;
+	                _this.axis = {
+	                  x: _axis.indexOf('x') >= 0,
+	                  y: _axis.indexOf('y') >= 0
+	                };
+	                _this.offsetEdge = getEdgeOffset(_node, _this.container);
+
+	                if (_isKeySorting) {
+	                  _this.initialOffset = getPosition(_objectSpread$7({}, event, {
+	                    pageX: _this.boundingClientRect.left,
+	                    pageY: _this.boundingClientRect.top
+	                  }));
+	                } else {
+	                  _this.initialOffset = getPosition(event);
+	                }
+
+	                _this.initialScroll = {
+	                  left: _this.scrollContainer.scrollLeft,
+	                  top: _this.scrollContainer.scrollTop
+	                };
+	                _this.initialWindowScroll = {
+	                  left: window.pageXOffset,
+	                  top: window.pageYOffset
+	                };
+	                _this.helper = _this.helperContainer.appendChild(cloneNode(_node));
+	                setInlineStyles(_this.helper, {
+	                  boxSizing: 'border-box',
+	                  height: "".concat(_this.height, "px"),
+	                  left: "".concat(_this.boundingClientRect.left - margin.left, "px"),
+	                  pointerEvents: 'none',
+	                  position: 'fixed',
+	                  top: "".concat(_this.boundingClientRect.top - margin.top, "px"),
+	                  width: "".concat(_this.width, "px")
+	                });
+
+	                if (_isKeySorting) {
+	                  _this.helper.focus();
+	                }
+
+	                if (_hideSortableGhost) {
+	                  _this.sortableGhost = _node;
+	                  setInlineStyles(_node, {
+	                    opacity: 0,
+	                    visibility: 'hidden'
+	                  });
+	                }
+
+	                _this.minTranslate = {};
+	                _this.maxTranslate = {};
+
+	                if (_isKeySorting) {
+	                  var _ref = _useWindowAsScrollContainer ? {
+	                    top: 0,
+	                    left: 0,
+	                    width: _this.contentWindow.innerWidth,
+	                    height: _this.contentWindow.innerHeight
+	                  } : _this.containerBoundingRect,
+	                      containerTop = _ref.top,
+	                      containerLeft = _ref.left,
+	                      containerWidth = _ref.width,
+	                      containerHeight = _ref.height;
+
+	                  var containerBottom = containerTop + containerHeight;
+	                  var containerRight = containerLeft + containerWidth;
+
+	                  if (_this.axis.x) {
+	                    _this.minTranslate.x = containerLeft - _this.boundingClientRect.left;
+	                    _this.maxTranslate.x = containerRight - (_this.boundingClientRect.left + _this.width);
+	                  }
+
+	                  if (_this.axis.y) {
+	                    _this.minTranslate.y = containerTop - _this.boundingClientRect.top;
+	                    _this.maxTranslate.y = containerBottom - (_this.boundingClientRect.top + _this.height);
+	                  }
+	                } else {
+	                  if (_this.axis.x) {
+	                    _this.minTranslate.x = (_useWindowAsScrollContainer ? 0 : containerBoundingRect.left) - _this.boundingClientRect.left - _this.width / 2;
+	                    _this.maxTranslate.x = (_useWindowAsScrollContainer ? _this.contentWindow.innerWidth : containerBoundingRect.left + containerBoundingRect.width) - _this.boundingClientRect.left - _this.width / 2;
+	                  }
+
+	                  if (_this.axis.y) {
+	                    _this.minTranslate.y = (_useWindowAsScrollContainer ? 0 : containerBoundingRect.top) - _this.boundingClientRect.top - _this.height / 2;
+	                    _this.maxTranslate.y = (_useWindowAsScrollContainer ? _this.contentWindow.innerHeight : containerBoundingRect.top + containerBoundingRect.height) - _this.boundingClientRect.top - _this.height / 2;
+	                  }
+	                }
+
+	                if (_helperClass) {
+	                  _helperClass.split(' ').forEach(function (className) {
+	                    return _this.helper.classList.add(className);
+	                  });
+	                }
+
+	                _this.listenerNode = event.touches ? event.target : _this.contentWindow;
+
+	                if (_isKeySorting) {
+	                  _this.listenerNode.addEventListener('wheel', _this.handleKeyEnd, true);
+
+	                  _this.listenerNode.addEventListener('mousedown', _this.handleKeyEnd, true);
+
+	                  _this.listenerNode.addEventListener('keydown', _this.handleKeyDown);
+	                } else {
+	                  events$1.move.forEach(function (eventName) {
+	                    return _this.listenerNode.addEventListener(eventName, _this.handleSortMove, false);
+	                  });
+	                  events$1.end.forEach(function (eventName) {
+	                    return _this.listenerNode.addEventListener(eventName, _this.handleSortEnd, false);
+	                  });
+	                }
+
+	                _this.setState({
+	                  sorting: true,
+	                  sortingIndex: index
+	                });
+
+	                if (_onSortStart) {
+	                  _onSortStart({
+	                    node: _node,
+	                    index: index,
+	                    collection: _collection,
+	                    isKeySorting: _isKeySorting,
+	                    nodes: _this.manager.getOrderedRefs(),
+	                    helper: _this.helper
+	                  }, event);
+	                }
+
+	                if (_isKeySorting) {
+	                  _this.keyMove(0);
+	                }
+	              };
+
+	              var _this$props3 = _this.props,
+	                  _axis = _this$props3.axis,
+	                  _getHelperDimensions = _this$props3.getHelperDimensions,
+	                  _helperClass = _this$props3.helperClass,
+	                  _hideSortableGhost = _this$props3.hideSortableGhost,
+	                  updateBeforeSortStart = _this$props3.updateBeforeSortStart,
+	                  _onSortStart = _this$props3.onSortStart,
+	                  _useWindowAsScrollContainer = _this$props3.useWindowAsScrollContainer;
+	              var _node = active.node,
+	                  _collection = active.collection;
+	              var _isKeySorting = _this.manager.isKeySorting;
+
+	              var _temp8 = function () {
+	                if (typeof updateBeforeSortStart === 'function') {
+	                  _this._awaitingUpdateBeforeSortStart = true;
+
+	                  var _temp9 = _finallyRethrows(function () {
+	                    var index = _node.sortableInfo.index;
+	                    return Promise.resolve(updateBeforeSortStart({
+	                      collection: _collection,
+	                      index: index,
+	                      node: _node,
+	                      isKeySorting: _isKeySorting
+	                    }, event)).then(function () {});
+	                  }, function (_wasThrown, _result) {
+	                    _this._awaitingUpdateBeforeSortStart = false;
+	                    if (_wasThrown) throw _result;
+	                    return _result;
+	                  });
+
+	                  if (_temp9 && _temp9.then) return _temp9.then(function () {});
+	                }
+	              }();
+
+	              return _temp8 && _temp8.then ? _temp8.then(_temp7) : _temp7(_temp8);
+	            }
+	          }();
+
+	          return Promise.resolve(_temp6 && _temp6.then ? _temp6.then(function () {}) : void 0);
+	        } catch (e) {
+	          return Promise.reject(e);
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleSortMove", function (event) {
+	        var onSortMove = _this.props.onSortMove;
+
+	        if (typeof event.preventDefault === 'function' && event.cancelable) {
+	          event.preventDefault();
+	        }
+
+	        _this.updateHelperPosition(event);
+
+	        _this.animateNodes();
+
+	        _this.autoscroll();
+
+	        if (onSortMove) {
+	          onSortMove(event);
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleSortEnd", function (event) {
+	        var _this$props4 = _this.props,
+	            hideSortableGhost = _this$props4.hideSortableGhost,
+	            onSortEnd = _this$props4.onSortEnd;
+	        var _this$manager = _this.manager,
+	            collection = _this$manager.active.collection,
+	            isKeySorting = _this$manager.isKeySorting;
+
+	        var nodes = _this.manager.getOrderedRefs();
+
+	        if (_this.listenerNode) {
+	          if (isKeySorting) {
+	            _this.listenerNode.removeEventListener('wheel', _this.handleKeyEnd, true);
+
+	            _this.listenerNode.removeEventListener('mousedown', _this.handleKeyEnd, true);
+
+	            _this.listenerNode.removeEventListener('keydown', _this.handleKeyDown);
+	          } else {
+	            events$1.move.forEach(function (eventName) {
+	              return _this.listenerNode.removeEventListener(eventName, _this.handleSortMove);
+	            });
+	            events$1.end.forEach(function (eventName) {
+	              return _this.listenerNode.removeEventListener(eventName, _this.handleSortEnd);
+	            });
+	          }
+	        }
+
+	        _this.helper.parentNode.removeChild(_this.helper);
+
+	        if (hideSortableGhost && _this.sortableGhost) {
+	          setInlineStyles(_this.sortableGhost, {
+	            opacity: '',
+	            visibility: ''
+	          });
+	        }
+
+	        for (var i = 0, len = nodes.length; i < len; i++) {
+	          var _node2 = nodes[i];
+	          var el = _node2.node;
+	          _node2.edgeOffset = null;
+	          _node2.boundingClientRect = null;
+	          setTranslate3d(el, null);
+	          setTransitionDuration(el, null);
+	          _node2.translate = null;
+	        }
+
+	        _this.autoScroller.clear();
+
+	        _this.manager.active = null;
+	        _this.manager.isKeySorting = false;
+
+	        _this.setState({
+	          sorting: false,
+	          sortingIndex: null
+	        });
+
+	        if (typeof onSortEnd === 'function') {
+	          onSortEnd({
+	            collection: collection,
+	            newIndex: _this.newIndex,
+	            oldIndex: _this.index,
+	            isKeySorting: isKeySorting,
+	            nodes: nodes
+	          }, event);
+	        }
+
+	        _this.touched = false;
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "autoscroll", function () {
+	        var disableAutoscroll = _this.props.disableAutoscroll;
+	        var isKeySorting = _this.manager.isKeySorting;
+
+	        if (disableAutoscroll) {
+	          _this.autoScroller.clear();
+
+	          return;
+	        }
+
+	        if (isKeySorting) {
+	          var translate = _objectSpread$7({}, _this.translate);
+
+	          var scrollX = 0;
+	          var scrollY = 0;
+
+	          if (_this.axis.x) {
+	            translate.x = Math.min(_this.maxTranslate.x, Math.max(_this.minTranslate.x, _this.translate.x));
+	            scrollX = _this.translate.x - translate.x;
+	          }
+
+	          if (_this.axis.y) {
+	            translate.y = Math.min(_this.maxTranslate.y, Math.max(_this.minTranslate.y, _this.translate.y));
+	            scrollY = _this.translate.y - translate.y;
+	          }
+
+	          _this.translate = translate;
+	          setTranslate3d(_this.helper, _this.translate);
+	          _this.scrollContainer.scrollLeft += scrollX;
+	          _this.scrollContainer.scrollTop += scrollY;
+	          return;
+	        }
+
+	        _this.autoScroller.update({
+	          height: _this.height,
+	          maxTranslate: _this.maxTranslate,
+	          minTranslate: _this.minTranslate,
+	          translate: _this.translate,
+	          width: _this.width
+	        });
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "onAutoScroll", function (offset) {
+	        _this.translate.x += offset.left;
+	        _this.translate.y += offset.top;
+
+	        _this.animateNodes();
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleKeyDown", function (event) {
+	        var keyCode = event.keyCode;
+	        var _this$props5 = _this.props,
+	            shouldCancelStart = _this$props5.shouldCancelStart,
+	            _this$props5$keyCodes = _this$props5.keyCodes,
+	            customKeyCodes = _this$props5$keyCodes === void 0 ? {} : _this$props5$keyCodes;
+
+	        var keyCodes = _objectSpread$7({}, defaultKeyCodes, customKeyCodes);
+
+	        if (_this.manager.active && !_this.manager.isKeySorting || !_this.manager.active && (!keyCodes.lift.includes(keyCode) || shouldCancelStart(event) || !_this.isValidSortingTarget(event))) {
+	          return;
+	        }
+
+	        event.stopPropagation();
+	        event.preventDefault();
+
+	        if (keyCodes.lift.includes(keyCode) && !_this.manager.active) {
+	          _this.keyLift(event);
+	        } else if (keyCodes.drop.includes(keyCode) && _this.manager.active) {
+	          _this.keyDrop(event);
+	        } else if (keyCodes.cancel.includes(keyCode)) {
+	          _this.newIndex = _this.manager.active.index;
+
+	          _this.keyDrop(event);
+	        } else if (keyCodes.up.includes(keyCode)) {
+	          _this.keyMove(-1);
+	        } else if (keyCodes.down.includes(keyCode)) {
+	          _this.keyMove(1);
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "keyLift", function (event) {
+	        var target = event.target;
+	        var node = closest(target, function (el) {
+	          return el.sortableInfo != null;
+	        });
+	        var _node$sortableInfo2 = node.sortableInfo,
+	            index = _node$sortableInfo2.index,
+	            collection = _node$sortableInfo2.collection;
+	        _this.initialFocusedNode = target;
+	        _this.manager.isKeySorting = true;
+	        _this.manager.active = {
+	          index: index,
+	          collection: collection
+	        };
+
+	        _this.handlePress(event);
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "keyMove", function (shift) {
+	        var nodes = _this.manager.getOrderedRefs();
+
+	        var lastIndex = nodes[nodes.length - 1].node.sortableInfo.index;
+	        var newIndex = _this.newIndex + shift;
+	        var prevIndex = _this.newIndex;
+
+	        if (newIndex < 0 || newIndex > lastIndex) {
+	          return;
+	        }
+
+	        _this.prevIndex = prevIndex;
+	        _this.newIndex = newIndex;
+	        var targetIndex = getTargetIndex(_this.newIndex, _this.prevIndex, _this.index);
+	        var target = nodes.find(function (_ref2) {
+	          var node = _ref2.node;
+	          return node.sortableInfo.index === targetIndex;
+	        });
+	        var targetNode = target.node;
+	        var scrollDelta = _this.containerScrollDelta;
+	        var targetBoundingClientRect = target.boundingClientRect || getScrollAdjustedBoundingClientRect(targetNode, scrollDelta);
+	        var targetTranslate = target.translate || {
+	          x: 0,
+	          y: 0
+	        };
+	        var targetPosition = {
+	          top: targetBoundingClientRect.top + targetTranslate.y - scrollDelta.top,
+	          left: targetBoundingClientRect.left + targetTranslate.x - scrollDelta.left
+	        };
+	        var shouldAdjustForSize = prevIndex < newIndex;
+	        var sizeAdjustment = {
+	          x: shouldAdjustForSize && _this.axis.x ? targetNode.offsetWidth - _this.width : 0,
+	          y: shouldAdjustForSize && _this.axis.y ? targetNode.offsetHeight - _this.height : 0
+	        };
+
+	        _this.handleSortMove({
+	          pageX: targetPosition.left + sizeAdjustment.x,
+	          pageY: targetPosition.top + sizeAdjustment.y,
+	          ignoreTransition: shift === 0
+	        });
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "keyDrop", function (event) {
+	        _this.handleSortEnd(event);
+
+	        if (_this.initialFocusedNode) {
+	          _this.initialFocusedNode.focus();
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "handleKeyEnd", function (event) {
+	        if (_this.manager.active) {
+	          _this.keyDrop(event);
+	        }
+	      });
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "isValidSortingTarget", function (event) {
+	        var useDragHandle = _this.props.useDragHandle;
+	        var target = event.target;
+	        var node = closest(target, function (el) {
+	          return el.sortableInfo != null;
+	        });
+	        return node && node.sortableInfo && !node.sortableInfo.disabled && (useDragHandle ? isSortableHandle(target) : target.sortableInfo);
+	      });
+
+	      var manager = new Manager();
+	      validateProps(props);
+	      _this.manager = manager;
+	      _this.wrappedInstance = React.createRef();
+	      _this.sortableContextValue = {
+	        manager: manager
+	      };
+	      _this.events = {
+	        end: _this.handleEnd,
+	        move: _this.handleMove,
+	        start: _this.handleStart
+	      };
+	      return _this;
+	    }
+
+	    _createClass(WithSortableContainer, [{
+	      key: "componentDidMount",
+	      value: function componentDidMount() {
+	        var _this2 = this;
+
+	        var useWindowAsScrollContainer = this.props.useWindowAsScrollContainer;
+	        var container = this.getContainer();
+	        Promise.resolve(container).then(function (containerNode) {
+	          _this2.container = containerNode;
+	          _this2.document = _this2.container.ownerDocument || document;
+	          var contentWindow = _this2.props.contentWindow || _this2.document.defaultView || window;
+	          _this2.contentWindow = typeof contentWindow === 'function' ? contentWindow() : contentWindow;
+	          _this2.scrollContainer = useWindowAsScrollContainer ? _this2.document.scrollingElement || _this2.document.documentElement : getScrollingParent(_this2.container) || _this2.container;
+	          _this2.autoScroller = new AutoScroller(_this2.scrollContainer, _this2.onAutoScroll);
+	          Object.keys(_this2.events).forEach(function (key) {
+	            return events$1[key].forEach(function (eventName) {
+	              return _this2.container.addEventListener(eventName, _this2.events[key], false);
+	            });
+	          });
+
+	          _this2.container.addEventListener('keydown', _this2.handleKeyDown);
+	        });
+	      }
+	    }, {
+	      key: "componentWillUnmount",
+	      value: function componentWillUnmount() {
+	        var _this3 = this;
+
+	        if (this.helper && this.helper.parentNode) {
+	          this.helper.parentNode.removeChild(this.helper);
+	        }
+
+	        if (!this.container) {
+	          return;
+	        }
+
+	        Object.keys(this.events).forEach(function (key) {
+	          return events$1[key].forEach(function (eventName) {
+	            return _this3.container.removeEventListener(eventName, _this3.events[key]);
+	          });
+	        });
+	        this.container.removeEventListener('keydown', this.handleKeyDown);
+	      }
+	    }, {
+	      key: "updateHelperPosition",
+	      value: function updateHelperPosition(event) {
+	        var _this$props6 = this.props,
+	            lockAxis = _this$props6.lockAxis,
+	            lockOffset = _this$props6.lockOffset,
+	            lockToContainerEdges = _this$props6.lockToContainerEdges,
+	            transitionDuration = _this$props6.transitionDuration,
+	            _this$props6$keyboard = _this$props6.keyboardSortingTransitionDuration,
+	            keyboardSortingTransitionDuration = _this$props6$keyboard === void 0 ? transitionDuration : _this$props6$keyboard;
+	        var isKeySorting = this.manager.isKeySorting;
+	        var ignoreTransition = event.ignoreTransition;
+	        var offset = getPosition(event);
+	        var translate = {
+	          x: offset.x - this.initialOffset.x,
+	          y: offset.y - this.initialOffset.y
+	        };
+	        translate.y -= window.pageYOffset - this.initialWindowScroll.top;
+	        translate.x -= window.pageXOffset - this.initialWindowScroll.left;
+	        this.translate = translate;
+
+	        if (lockToContainerEdges) {
+	          var _getLockPixelOffsets = getLockPixelOffsets({
+	            height: this.height,
+	            lockOffset: lockOffset,
+	            width: this.width
+	          }),
+	              _getLockPixelOffsets2 = _slicedToArray$1(_getLockPixelOffsets, 2),
+	              minLockOffset = _getLockPixelOffsets2[0],
+	              maxLockOffset = _getLockPixelOffsets2[1];
+
+	          var minOffset = {
+	            x: this.width / 2 - minLockOffset.x,
+	            y: this.height / 2 - minLockOffset.y
+	          };
+	          var maxOffset = {
+	            x: this.width / 2 - maxLockOffset.x,
+	            y: this.height / 2 - maxLockOffset.y
+	          };
+	          translate.x = limit(this.minTranslate.x + minOffset.x, this.maxTranslate.x - maxOffset.x, translate.x);
+	          translate.y = limit(this.minTranslate.y + minOffset.y, this.maxTranslate.y - maxOffset.y, translate.y);
+	        }
+
+	        if (lockAxis === 'x') {
+	          translate.y = 0;
+	        } else if (lockAxis === 'y') {
+	          translate.x = 0;
+	        }
+
+	        if (isKeySorting && keyboardSortingTransitionDuration && !ignoreTransition) {
+	          setTransitionDuration(this.helper, keyboardSortingTransitionDuration);
+	        }
+
+	        setTranslate3d(this.helper, translate);
+	      }
+	    }, {
+	      key: "animateNodes",
+	      value: function animateNodes() {
+	        var _this$props7 = this.props,
+	            transitionDuration = _this$props7.transitionDuration,
+	            hideSortableGhost = _this$props7.hideSortableGhost,
+	            onSortOver = _this$props7.onSortOver;
+	        var containerScrollDelta = this.containerScrollDelta,
+	            windowScrollDelta = this.windowScrollDelta;
+	        var nodes = this.manager.getOrderedRefs();
+	        var sortingOffset = {
+	          left: this.offsetEdge.left + this.translate.x + containerScrollDelta.left,
+	          top: this.offsetEdge.top + this.translate.y + containerScrollDelta.top
+	        };
+	        var isKeySorting = this.manager.isKeySorting;
+	        var prevIndex = this.newIndex;
+	        this.newIndex = null;
+
+	        for (var i = 0, len = nodes.length; i < len; i++) {
+	          var _node3 = nodes[i].node;
+	          var index = _node3.sortableInfo.index;
+	          var width = _node3.offsetWidth;
+	          var height = _node3.offsetHeight;
+	          var offset = {
+	            height: this.height > height ? height / 2 : this.height / 2,
+	            width: this.width > width ? width / 2 : this.width / 2
+	          };
+	          var mustShiftBackward = isKeySorting && index > this.index && index <= prevIndex;
+	          var mustShiftForward = isKeySorting && index < this.index && index >= prevIndex;
+	          var translate = {
+	            x: 0,
+	            y: 0
+	          };
+	          var edgeOffset = nodes[i].edgeOffset;
+
+	          if (!edgeOffset) {
+	            edgeOffset = getEdgeOffset(_node3, this.container);
+	            nodes[i].edgeOffset = edgeOffset;
+
+	            if (isKeySorting) {
+	              nodes[i].boundingClientRect = getScrollAdjustedBoundingClientRect(_node3, containerScrollDelta);
+	            }
+	          }
+
+	          var nextNode = i < nodes.length - 1 && nodes[i + 1];
+	          var prevNode = i > 0 && nodes[i - 1];
+
+	          if (nextNode && !nextNode.edgeOffset) {
+	            nextNode.edgeOffset = getEdgeOffset(nextNode.node, this.container);
+
+	            if (isKeySorting) {
+	              nextNode.boundingClientRect = getScrollAdjustedBoundingClientRect(nextNode.node, containerScrollDelta);
+	            }
+	          }
+
+	          if (index === this.index) {
+	            if (hideSortableGhost) {
+	              this.sortableGhost = _node3;
+	              setInlineStyles(_node3, {
+	                opacity: 0,
+	                visibility: 'hidden'
+	              });
+	            }
+
+	            continue;
+	          }
+
+	          if (transitionDuration) {
+	            setTransitionDuration(_node3, transitionDuration);
+	          }
+
+	          if (this.axis.x) {
+	            if (this.axis.y) {
+	              if (mustShiftForward || index < this.index && (sortingOffset.left + windowScrollDelta.left - offset.width <= edgeOffset.left && sortingOffset.top + windowScrollDelta.top <= edgeOffset.top + offset.height || sortingOffset.top + windowScrollDelta.top + offset.height <= edgeOffset.top)) {
+	                translate.x = this.width + this.marginOffset.x;
+
+	                if (edgeOffset.left + translate.x > this.containerBoundingRect.width - offset.width) {
+	                  if (nextNode) {
+	                    translate.x = nextNode.edgeOffset.left - edgeOffset.left;
+	                    translate.y = nextNode.edgeOffset.top - edgeOffset.top;
+	                  }
+	                }
+
+	                if (this.newIndex === null) {
+	                  this.newIndex = index;
+	                }
+	              } else if (mustShiftBackward || index > this.index && (sortingOffset.left + windowScrollDelta.left + offset.width >= edgeOffset.left && sortingOffset.top + windowScrollDelta.top + offset.height >= edgeOffset.top || sortingOffset.top + windowScrollDelta.top + offset.height >= edgeOffset.top + height)) {
+	                translate.x = -(this.width + this.marginOffset.x);
+
+	                if (edgeOffset.left + translate.x < this.containerBoundingRect.left + offset.width) {
+	                  if (prevNode) {
+	                    translate.x = prevNode.edgeOffset.left - edgeOffset.left;
+	                    translate.y = prevNode.edgeOffset.top - edgeOffset.top;
+	                  }
+	                }
+
+	                this.newIndex = index;
+	              }
+	            } else {
+	              if (mustShiftBackward || index > this.index && sortingOffset.left + windowScrollDelta.left + offset.width >= edgeOffset.left) {
+	                translate.x = -(this.width + this.marginOffset.x);
+	                this.newIndex = index;
+	              } else if (mustShiftForward || index < this.index && sortingOffset.left + windowScrollDelta.left <= edgeOffset.left + offset.width) {
+	                translate.x = this.width + this.marginOffset.x;
+
+	                if (this.newIndex == null) {
+	                  this.newIndex = index;
+	                }
+	              }
+	            }
+	          } else if (this.axis.y) {
+	            if (mustShiftBackward || index > this.index && sortingOffset.top + windowScrollDelta.top + offset.height >= edgeOffset.top) {
+	              translate.y = -(this.height + this.marginOffset.y);
+	              this.newIndex = index;
+	            } else if (mustShiftForward || index < this.index && sortingOffset.top + windowScrollDelta.top <= edgeOffset.top + offset.height) {
+	              translate.y = this.height + this.marginOffset.y;
+
+	              if (this.newIndex == null) {
+	                this.newIndex = index;
+	              }
+	            }
+	          }
+
+	          setTranslate3d(_node3, translate);
+	          nodes[i].translate = translate;
+	        }
+
+	        if (this.newIndex == null) {
+	          this.newIndex = this.index;
+	        }
+
+	        if (isKeySorting) {
+	          this.newIndex = prevIndex;
+	        }
+
+	        var oldIndex = isKeySorting ? this.prevIndex : prevIndex;
+
+	        if (onSortOver && this.newIndex !== oldIndex) {
+	          onSortOver({
+	            collection: this.manager.active.collection,
+	            index: this.index,
+	            newIndex: this.newIndex,
+	            oldIndex: oldIndex,
+	            isKeySorting: isKeySorting,
+	            nodes: nodes,
+	            helper: this.helper
+	          });
+	        }
+	      }
+	    }, {
+	      key: "getWrappedInstance",
+	      value: function getWrappedInstance() {
+	        invariant_1(config.withRef, 'To access the wrapped instance, you need to pass in {withRef: true} as the second argument of the SortableContainer() call');
+	        return this.wrappedInstance.current;
+	      }
+	    }, {
+	      key: "getContainer",
+	      value: function getContainer() {
+	        var getContainer = this.props.getContainer;
+
+	        if (typeof getContainer !== 'function') {
+	          return require$$2.findDOMNode(this);
+	        }
+
+	        return getContainer(config.withRef ? this.getWrappedInstance() : undefined);
+	      }
+	    }, {
+	      key: "render",
+	      value: function render() {
+	        var ref = config.withRef ? this.wrappedInstance : null;
+	        return React.createElement(SortableContext$1.Provider, {
+	          value: this.sortableContextValue
+	        }, React.createElement(WrappedComponent, _extends$5({
+	          ref: ref
+	        }, omit$1(this.props, omittedProps))));
+	      }
+	    }, {
+	      key: "helperContainer",
+	      get: function get() {
+	        var helperContainer = this.props.helperContainer;
+
+	        if (typeof helperContainer === 'function') {
+	          return helperContainer();
+	        }
+
+	        return this.props.helperContainer || this.document.body;
+	      }
+	    }, {
+	      key: "containerScrollDelta",
+	      get: function get() {
+	        var useWindowAsScrollContainer = this.props.useWindowAsScrollContainer;
+
+	        if (useWindowAsScrollContainer) {
+	          return {
+	            left: 0,
+	            top: 0
+	          };
+	        }
+
+	        return {
+	          left: this.scrollContainer.scrollLeft - this.initialScroll.left,
+	          top: this.scrollContainer.scrollTop - this.initialScroll.top
+	        };
+	      }
+	    }, {
+	      key: "windowScrollDelta",
+	      get: function get() {
+	        return {
+	          left: this.contentWindow.pageXOffset - this.initialWindowScroll.left,
+	          top: this.contentWindow.pageYOffset - this.initialWindowScroll.top
+	        };
+	      }
+	    }]);
+
+	    return WithSortableContainer;
+	  }(React.Component), _defineProperty$1(_class, "displayName", provideDisplayName('sortableList', WrappedComponent)), _defineProperty$1(_class, "defaultProps", defaultProps), _defineProperty$1(_class, "propTypes", propTypes$1), _temp;
+	}
+
+	var propTypes$1$1 = {
+	  index: propTypes.number.isRequired,
+	  collection: propTypes.oneOfType([propTypes.number, propTypes.string]),
+	  disabled: propTypes.bool
+	};
+	var omittedProps$1 = Object.keys(propTypes$1$1);
+	function sortableElement(WrappedComponent) {
+	  var _class, _temp;
+
+	  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+	    withRef: false
+	  };
+	  return _temp = _class = function (_React$Component) {
+	    _inherits(WithSortableElement, _React$Component);
+
+	    function WithSortableElement() {
+	      var _getPrototypeOf2;
+
+	      var _this;
+
+	      _classCallCheck(this, WithSortableElement);
+
+	      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+	        args[_key] = arguments[_key];
+	      }
+
+	      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WithSortableElement)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+	      _defineProperty$1(_assertThisInitialized(_assertThisInitialized(_this)), "wrappedInstance", React.createRef());
+
+	      return _this;
+	    }
+
+	    _createClass(WithSortableElement, [{
+	      key: "componentDidMount",
+	      value: function componentDidMount() {
+	        this.register();
+	      }
+	    }, {
+	      key: "componentDidUpdate",
+	      value: function componentDidUpdate(prevProps) {
+	        if (this.node) {
+	          if (prevProps.index !== this.props.index) {
+	            this.node.sortableInfo.index = this.props.index;
+	          }
+
+	          if (prevProps.disabled !== this.props.disabled) {
+	            this.node.sortableInfo.disabled = this.props.disabled;
+	          }
+	        }
+
+	        if (prevProps.collection !== this.props.collection) {
+	          this.unregister(prevProps.collection);
+	          this.register();
+	        }
+	      }
+	    }, {
+	      key: "componentWillUnmount",
+	      value: function componentWillUnmount() {
+	        this.unregister();
+	      }
+	    }, {
+	      key: "register",
+	      value: function register() {
+	        var _this$props = this.props,
+	            collection = _this$props.collection,
+	            disabled = _this$props.disabled,
+	            index = _this$props.index;
+	        var node = require$$2.findDOMNode(this);
+	        node.sortableInfo = {
+	          collection: collection,
+	          disabled: disabled,
+	          index: index,
+	          manager: this.context.manager
+	        };
+	        this.node = node;
+	        this.ref = {
+	          node: node
+	        };
+	        this.context.manager.add(collection, this.ref);
+	      }
+	    }, {
+	      key: "unregister",
+	      value: function unregister() {
+	        var collection = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props.collection;
+	        this.context.manager.remove(collection, this.ref);
+	      }
+	    }, {
+	      key: "getWrappedInstance",
+	      value: function getWrappedInstance() {
+	        invariant_1(config.withRef, 'To access the wrapped instance, you need to pass in {withRef: true} as the second argument of the SortableElement() call');
+	        return this.wrappedInstance.current;
+	      }
+	    }, {
+	      key: "render",
+	      value: function render() {
+	        var ref = config.withRef ? this.wrappedInstance : null;
+	        return React.createElement(WrappedComponent, _extends$5({
+	          ref: ref
+	        }, omit$1(this.props, omittedProps$1)));
+	      }
+	    }]);
+
+	    return WithSortableElement;
+	  }(React.Component), _defineProperty$1(_class, "displayName", provideDisplayName('sortableElement', WrappedComponent)), _defineProperty$1(_class, "contextType", SortableContext$1), _defineProperty$1(_class, "propTypes", propTypes$1$1), _defineProperty$1(_class, "defaultProps", {
+	    collection: 0
+	  }), _temp;
+	}
+
 	var ProCardActions = function ProCardActions(props) {
 	  var actions = props.actions,
 	      prefixCls = props.prefixCls;
@@ -73993,8 +75639,26 @@
 	  editConfig: editConfig
 	};
 
-	var _excluded$$ = ["dataSource", "autoSize", "columns", "rowClick", "onDoubleClick", "checkConfig", "summary", "pagination", "hiddenPage", "loading", "virtual", "customCheck", "rowSelection", "columnsState", "tableRowType"];
+	var _excluded$$ = ["dataSource", "autoSize", "columns", "rowClick", "onDoubleClick", "checkConfig", "summary", "pagination", "hiddenPage", "loading", "virtual", "sortOpen", "customCheck", "rowSelection", "columnsState", "tableRowType"],
+	    _excluded2$h = ["className", "style"];
 	var Summary = ProviderWarp.Summary;
+	var DragHandle = sortableHandle(function () {
+	  return /*#__PURE__*/React__default['default'].createElement(MenuOutlined$2, {
+	    style: {
+	      cursor: 'grab',
+	      color: '#999'
+	    }
+	  });
+	});
+	var sortDefaultColumnItem = {
+	  title: '排序',
+	  dataIndex: 'sort',
+	  width: 60,
+	  className: 'drag-visible',
+	  render: function render() {
+	    return /*#__PURE__*/React__default['default'].createElement(DragHandle, null);
+	  }
+	};
 	var ResetTable = /*#__PURE__*/React.forwardRef(function (props, ref) {
 	  var dataSource = props.dataSource,
 	      autoSize = props.autoSize,
@@ -74007,7 +75671,8 @@
 	      hiddenPage = props.hiddenPage,
 	      loading = props.loading,
 	      _props$virtual = props.virtual,
-	      virtual = _props$virtual === void 0 ? false : _props$virtual,
+	      _props$sortOpen = props.sortOpen,
+	      sortOpen = _props$sortOpen === void 0 ? false : _props$sortOpen,
 	      customCheck = props.customCheck,
 	      rowSelection = props.rowSelection,
 	      columnsState = props.columnsState,
@@ -74041,7 +75706,49 @@
 	  var _useState7 = React.useState(),
 	      _useState8 = _slicedToArray(_useState7, 2),
 	      columnsStateMap = _useState8[0],
-	      setColumnsStateMap = _useState8[1]; // 原宽度，先宽度，序号
+	      setColumnsStateMap = _useState8[1];
+
+	  var SortableItem = sortableElement(function (props) {
+	    return /*#__PURE__*/React__default['default'].createElement("tr", props);
+	  });
+	  var SortContainer = sortableContainer(function (props) {
+	    return /*#__PURE__*/React__default['default'].createElement("tbody", props);
+	  });
+
+	  var onSortEnd = function onSortEnd(_ref) {
+	    var oldIndex = _ref.oldIndex,
+	        newIndex = _ref.newIndex;
+
+	    if (oldIndex !== newIndex) {
+	      var newData = arrayMove(dataSource, oldIndex, newIndex).filter(function (el) {
+	        return !!el;
+	      });
+	      console.log(newData, 'nnnnnn'); // setDataSource([...newData])
+	    }
+	  };
+
+	  var DraggableContainer = function DraggableContainer(props) {
+	    return /*#__PURE__*/React__default['default'].createElement(SortContainer, _extends({
+	      useDragHandle: true,
+	      disableAutoscroll: true,
+	      helperClass: "row-dragging",
+	      onSortEnd: onSortEnd
+	    }, props));
+	  };
+
+	  var DraggableBodyRow = function DraggableBodyRow(props) {
+	    var className = props.className,
+	        style = props.style,
+	        restProps = _objectWithoutProperties(props, _excluded2$h);
+
+	    var index = dataSource.findIndex(function (x) {
+	      return x[rowKey || 'index'] === restProps['data-row-key'];
+	    });
+	    console.log(dataSource, restProps, 222, index);
+	    return /*#__PURE__*/React__default['default'].createElement(SortableItem, _extends({
+	      index: index
+	    }, restProps));
+	  }; // 原宽度，先宽度，序号
 
 
 	  var handleResize = function handleResize(sc, size, index) {
@@ -74058,7 +75765,7 @@
 	  };
 
 	  var resetColumns = React.useCallback(function () {
-	    return useColumns.filter(function (item) {
+	    var result = useColumns.filter(function (item) {
 	      return item.show !== false;
 	    }).map(function (col, index) {
 	      return _objectSpread(_objectSpread({}, col), {}, {
@@ -74073,7 +75780,9 @@
 	        }
 	      });
 	    });
-	  }, [useColumns]);
+	    console.log(sortOpen ? [sortDefaultColumnItem].concat(_toConsumableArray(result)) : result, sortOpen, 111);
+	    return sortOpen ? [sortDefaultColumnItem].concat(_toConsumableArray(result)) : result;
+	  }, [useColumns, sortOpen]);
 	  React.useEffect(function () {
 	    setColumns(columns);
 	  }, [columns]); // 行点击事件
@@ -74211,10 +75920,10 @@
 
 	    columns === null || columns === void 0 ? void 0 : columns.forEach(function (item) {
 	      /** 目前支持三种 */
-	      var _ref = obj[item.dataIndex || item.key] || {},
-	          order = _ref.order,
-	          show = _ref.show,
-	          fixed = _ref.fixed;
+	      var _ref2 = obj[item.dataIndex || item.key] || {},
+	          order = _ref2.order,
+	          show = _ref2.show,
+	          fixed = _ref2.fixed;
 
 	      obj[item.dataIndex || item.key] = {
 	        fixed: fixed || item.fixed,
@@ -74282,7 +75991,12 @@
 	  }, /*#__PURE__*/React__default['default'].createElement(ProviderWarp, _extends({}, config, {
 	    loading: loading,
 	    dataSource: dataSource,
-	    components: virtual ? vComponents : null,
+	    components: sortOpen ? {
+	      body: {
+	        wrapper: DraggableContainer,
+	        row: DraggableBodyRow
+	      }
+	    } : null,
 	    tableClassName: "lm_protable",
 	    summary: function summary(pageData) {
 	      return _summary && _summary(pageData, resultColumns);
@@ -76731,7 +78445,7 @@
 	};
 
 	var _excluded$12 = ["item"],
-	    _excluded2$h = ["item"],
+	    _excluded2$i = ["item"],
 	    _excluded3$4 = ["type"];
 
 	var imgEmpty$1 = require('./icon_placeholder.png');
@@ -76913,7 +78627,7 @@
 	    className: "filter_list"
 	  }, function (_ref6) {
 	    var item = _ref6.item,
-	        resetProps = _objectWithoutProperties(_ref6, _excluded2$h);
+	        resetProps = _objectWithoutProperties(_ref6, _excluded2$i);
 
 	    return /*#__PURE__*/React__default['default'].createElement("div", _objectSpread(_objectSpread({}, resetProps), {}, {
 	      className: classnames('filter_item', {
@@ -79970,7 +81684,7 @@
 	}
 	});
 
-	var propTypes$1 = createCommonjsModule(function (module, exports) {
+	var propTypes$2 = createCommonjsModule(function (module, exports) {
 
 	exports.__esModule = true;
 	exports.resizableProps = void 0;
@@ -80358,7 +82072,7 @@
 	}(React.Component);
 
 	exports.default = Resizable;
-	Resizable.propTypes = propTypes$1.resizableProps;
+	Resizable.propTypes = propTypes$2.resizableProps;
 	Resizable.defaultProps = {
 	  axis: 'both',
 	  handleSize: [20, 20],
@@ -80505,7 +82219,7 @@
 	}(React.Component);
 
 	exports.default = ResizableBox;
-	ResizableBox.propTypes = _objectSpread(_objectSpread({}, propTypes$1.resizableProps), {}, {
+	ResizableBox.propTypes = _objectSpread(_objectSpread({}, propTypes$2.resizableProps), {}, {
 	  children: _propTypes.default.element
 	});
 	});
@@ -80514,7 +82228,7 @@
 	var ResizableBox = ResizableBox_1.default;
 
 	var _excluded$1e = ["width", "onResize", "children"],
-	    _excluded2$i = ["children"],
+	    _excluded2$j = ["children"],
 	    _excluded3$5 = ["children", "style"],
 	    _excluded4$2 = ["children"],
 	    _excluded5$1 = ["style", "children"],
@@ -80681,7 +82395,7 @@
 
 	var VCell = function VCell(props) {
 	  var children = props.children,
-	      restProps = _objectWithoutProperties(props, _excluded2$i);
+	      restProps = _objectWithoutProperties(props, _excluded2$j);
 
 	  return /*#__PURE__*/React__default['default'].createElement("td", restProps, children);
 	};
@@ -81882,7 +83596,7 @@
 	ResizeSize$2.Summary = Summary$1;
 
 	var _excluded$1i = ["children"],
-	    _excluded2$j = ["children", "size", "buttonStyle", "direction", "className"];
+	    _excluded2$k = ["children", "size", "buttonStyle", "direction", "className"];
 
 	var LMRadio = function LMRadio(props) {
 	  var children = props.children,
@@ -81901,7 +83615,7 @@
 	      _props$direction = props.direction,
 	      direction = _props$direction === void 0 ? 'row' : _props$direction,
 	      className = props.className,
-	      restProps = _objectWithoutProperties(props, _excluded2$j);
+	      restProps = _objectWithoutProperties(props, _excluded2$k);
 
 	  console.log(children, 'rrr');
 	  return /*#__PURE__*/React__default['default'].createElement(_Radio__default['default'].Group, _extends({
@@ -82621,12 +84335,11 @@
 	    setVisible(false);
 	  };
 
-	  return /*#__PURE__*/React__default['default'].createElement(React__default['default'].Fragment, null, /*#__PURE__*/React__default['default'].createElement(IconFont$1, {
-	    type: 'lmweb-setting',
-	    style: {
-	      fontSize: '20px'
-	    },
-	    onClick: openSetting
+	  return /*#__PURE__*/React__default['default'].createElement(React__default['default'].Fragment, null, /*#__PURE__*/React__default['default'].createElement(LMButton, {
+	    onClick: openSetting,
+	    icon: /*#__PURE__*/React__default['default'].createElement(IconFont$1, {
+	      type: 'lmweb-setting'
+	    })
 	  }), /*#__PURE__*/React__default['default'].createElement(LMDrawer, {
 	    className: classnames(className, prefixCls$b),
 	    title: "\u4E2A\u6027\u5316\u8BBE\u7F6E",