@m4l/components 0.1.35 → 0.1.36

package/dist/node_modules.e0b84fac.js

@@ -0,0 +1,2154 @@
+import React__default from "react";
+import require$$0 from "lodash.isequal";
+import clsx from "clsx";
+import { u as utils } from "./utils/index.9dce2e2f.js";
+import require$$1 from "prop-types";
+import { c as cjs } from "./react-draggable.3b5b6680.js";
+import { r as reactResizable } from "./react-resizable.6eae0397.js";
+var cssUnit = {
+  cm: true,
+  mm: true,
+  in: true,
+  px: true,
+  pt: true,
+  pc: true,
+  em: true,
+  ex: true,
+  ch: true,
+  rem: true,
+  vw: true,
+  vh: true,
+  vmin: true,
+  vmax: true,
+  "%": true
+};
+function parseLengthAndUnit(size) {
+  if (typeof size === "number") {
+    return {
+      value: size,
+      unit: "px"
+    };
+  }
+  var value;
+  var valueString = (size.match(/^[0-9.]*/) || "").toString();
+  if (valueString.includes(".")) {
+    value = parseFloat(valueString);
+  } else {
+    value = parseInt(valueString, 10);
+  }
+  var unit = (size.match(/[^0-9]*$/) || "").toString();
+  if (cssUnit[unit]) {
+    return {
+      value,
+      unit
+    };
+  }
+  console.warn("React Spinners: ".concat(size, " is not a valid css value. Defaulting to ").concat(value, "px."));
+  return {
+    value,
+    unit: "px"
+  };
+}
+var createAnimation = function(loaderName, frames, suffix) {
+  var animationName = "react-spinners-".concat(loaderName, "-").concat(suffix);
+  if (typeof window == "undefined" || !window.document) {
+    return animationName;
+  }
+  var styleEl = document.createElement("style");
+  document.head.appendChild(styleEl);
+  var styleSheet = styleEl.sheet;
+  var keyFrames = "\n    @keyframes ".concat(animationName, " {\n      ").concat(frames, "\n    }\n  ");
+  if (styleSheet) {
+    styleSheet.insertRule(keyFrames, 0);
+  }
+  return animationName;
+};
+var reactGridLayout = { exports: {} };
+var ReactGridLayout$1 = {};
+var fastRGLPropsEqual = function fastRGLPropsEqual2(a, b, isEqualImpl) {
+  if (a === b)
+    return true;
+  return a.className === b.className && isEqualImpl(a.style, b.style) && a.width === b.width && a.autoSize === b.autoSize && a.cols === b.cols && a.draggableCancel === b.draggableCancel && a.draggableHandle === b.draggableHandle && isEqualImpl(a.verticalCompact, b.verticalCompact) && isEqualImpl(a.compactType, b.compactType) && isEqualImpl(a.layout, b.layout) && isEqualImpl(a.margin, b.margin) && isEqualImpl(a.containerPadding, b.containerPadding) && a.rowHeight === b.rowHeight && a.maxRows === b.maxRows && a.isBounded === b.isBounded && a.isDraggable === b.isDraggable && a.isResizable === b.isResizable && a.allowOverlap === b.allowOverlap && a.preventCollision === b.preventCollision && a.useCSSTransforms === b.useCSSTransforms && a.transformScale === b.transformScale && a.isDroppable === b.isDroppable && isEqualImpl(a.resizeHandles, b.resizeHandles) && isEqualImpl(a.resizeHandle, b.resizeHandle) && a.onLayoutChange === b.onLayoutChange && a.onDragStart === b.onDragStart && a.onDrag === b.onDrag && a.onDragStop === b.onDragStop && a.onResizeStart === b.onResizeStart && a.onResize === b.onResize && a.onResizeStop === b.onResizeStop && a.onDrop === b.onDrop && isEqualImpl(a.droppingItem, b.droppingItem) && isEqualImpl(a.innerRef, b.innerRef);
+};
+var calculateUtils = {};
+Object.defineProperty(calculateUtils, "__esModule", {
+  value: true
+});
+calculateUtils.calcGridColWidth = calcGridColWidth;
+calculateUtils.calcGridItemPosition = calcGridItemPosition;
+calculateUtils.calcGridItemWHPx = calcGridItemWHPx;
+calculateUtils.calcWH = calcWH;
+calculateUtils.calcXY = calcXY;
+calculateUtils.clamp = clamp;
+function calcGridColWidth(positionParams) {
+  var margin = positionParams.margin, containerPadding = positionParams.containerPadding, containerWidth = positionParams.containerWidth, cols = positionParams.cols;
+  return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;
+}
+function calcGridItemWHPx(gridUnits, colOrRowSize, marginPx) {
+  if (!Number.isFinite(gridUnits))
+    return gridUnits;
+  return Math.round(colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx);
+}
+function calcGridItemPosition(positionParams, x, y, w, h, state) {
+  var margin = positionParams.margin, containerPadding = positionParams.containerPadding, rowHeight = positionParams.rowHeight;
+  var colWidth = calcGridColWidth(positionParams);
+  var out = {};
+  if (state && state.resizing) {
+    out.width = Math.round(state.resizing.width);
+    out.height = Math.round(state.resizing.height);
+  } else {
+    out.width = calcGridItemWHPx(w, colWidth, margin[0]);
+    out.height = calcGridItemWHPx(h, rowHeight, margin[1]);
+  }
+  if (state && state.dragging) {
+    out.top = Math.round(state.dragging.top);
+    out.left = Math.round(state.dragging.left);
+  } else {
+    out.top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);
+    out.left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);
+  }
+  return out;
+}
+function calcXY(positionParams, top, left, w, h) {
+  var margin = positionParams.margin, cols = positionParams.cols, rowHeight = positionParams.rowHeight, maxRows = positionParams.maxRows;
+  var colWidth = calcGridColWidth(positionParams);
+  var x = Math.round((left - margin[0]) / (colWidth + margin[0]));
+  var y = Math.round((top - margin[1]) / (rowHeight + margin[1]));
+  x = clamp(x, 0, cols - w);
+  y = clamp(y, 0, maxRows - h);
+  return {
+    x,
+    y
+  };
+}
+function calcWH(positionParams, width, height, x, y) {
+  var margin = positionParams.margin, maxRows = positionParams.maxRows, cols = positionParams.cols, rowHeight = positionParams.rowHeight;
+  var colWidth = calcGridColWidth(positionParams);
+  var w = Math.round((width + margin[0]) / (colWidth + margin[0]));
+  var h = Math.round((height + margin[1]) / (rowHeight + margin[1]));
+  w = clamp(w, 0, cols - x);
+  h = clamp(h, 0, maxRows - y);
+  return {
+    w,
+    h
+  };
+}
+function clamp(num, lowerBound, upperBound) {
+  return Math.max(Math.min(num, upperBound), lowerBound);
+}
+var GridItem$1 = {};
+var ReactGridLayoutPropTypes = {};
+Object.defineProperty(ReactGridLayoutPropTypes, "__esModule", {
+  value: true
+});
+ReactGridLayoutPropTypes.resizeHandleType = ReactGridLayoutPropTypes.resizeHandleAxesType = ReactGridLayoutPropTypes.default = void 0;
+var _propTypes$3 = _interopRequireDefault$4(require$$1);
+var _react$1 = _interopRequireDefault$4(React__default);
+function _interopRequireDefault$4(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var resizeHandleAxesType = _propTypes$3.default.arrayOf(_propTypes$3.default.oneOf(["s", "w", "e", "n", "sw", "nw", "se", "ne"]));
+ReactGridLayoutPropTypes.resizeHandleAxesType = resizeHandleAxesType;
+var resizeHandleType = _propTypes$3.default.oneOfType([_propTypes$3.default.node, _propTypes$3.default.func]);
+ReactGridLayoutPropTypes.resizeHandleType = resizeHandleType;
+var _default = {
+  className: _propTypes$3.default.string,
+  style: _propTypes$3.default.object,
+  width: _propTypes$3.default.number,
+  autoSize: _propTypes$3.default.bool,
+  cols: _propTypes$3.default.number,
+  draggableCancel: _propTypes$3.default.string,
+  draggableHandle: _propTypes$3.default.string,
+  verticalCompact: function verticalCompact(props) {
+    if (props.verticalCompact === false && process.env.NODE_ENV !== "production") {
+      console.warn(
+        '`verticalCompact` on <ReactGridLayout> is deprecated and will be removed soon. Use `compactType`: "horizontal" | "vertical" | null.'
+      );
+    }
+  },
+  compactType: _propTypes$3.default.oneOf(["vertical", "horizontal"]),
+  layout: function layout(props) {
+    var layout2 = props.layout;
+    if (layout2 === void 0)
+      return;
+    utils.validateLayout(layout2, "layout");
+  },
+  margin: _propTypes$3.default.arrayOf(_propTypes$3.default.number),
+  containerPadding: _propTypes$3.default.arrayOf(_propTypes$3.default.number),
+  rowHeight: _propTypes$3.default.number,
+  maxRows: _propTypes$3.default.number,
+  isBounded: _propTypes$3.default.bool,
+  isDraggable: _propTypes$3.default.bool,
+  isResizable: _propTypes$3.default.bool,
+  allowOverlap: _propTypes$3.default.bool,
+  preventCollision: _propTypes$3.default.bool,
+  useCSSTransforms: _propTypes$3.default.bool,
+  transformScale: _propTypes$3.default.number,
+  isDroppable: _propTypes$3.default.bool,
+  resizeHandles: resizeHandleAxesType,
+  resizeHandle: resizeHandleType,
+  onLayoutChange: _propTypes$3.default.func,
+  onDragStart: _propTypes$3.default.func,
+  onDrag: _propTypes$3.default.func,
+  onDragStop: _propTypes$3.default.func,
+  onResizeStart: _propTypes$3.default.func,
+  onResize: _propTypes$3.default.func,
+  onResizeStop: _propTypes$3.default.func,
+  onDrop: _propTypes$3.default.func,
+  droppingItem: _propTypes$3.default.shape({
+    i: _propTypes$3.default.string.isRequired,
+    w: _propTypes$3.default.number.isRequired,
+    h: _propTypes$3.default.number.isRequired
+  }),
+  children: function children(props, propName) {
+    var children2 = props[propName];
+    var keys = {};
+    _react$1.default.Children.forEach(children2, function(child) {
+      if ((child === null || child === void 0 ? void 0 : child.key) == null)
+        return;
+      if (keys[child.key]) {
+        throw new Error('Duplicate child key "' + child.key + '" found! This will cause problems in ReactGridLayout.');
+      }
+      keys[child.key] = true;
+    });
+  },
+  innerRef: _propTypes$3.default.any
+};
+ReactGridLayoutPropTypes.default = _default;
+function _typeof$3(obj) {
+  "@babel/helpers - typeof";
+  return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof$3(obj);
+}
+Object.defineProperty(GridItem$1, "__esModule", {
+  value: true
+});
+GridItem$1.default = void 0;
+var _react = _interopRequireDefault$3(React__default);
+var _propTypes$2 = _interopRequireDefault$3(require$$1);
+var _reactDraggable = cjs.exports;
+var _reactResizable = reactResizable.exports;
+var _utils$3 = utils;
+var _calculateUtils$1 = calculateUtils;
+var _ReactGridLayoutPropTypes$1 = ReactGridLayoutPropTypes;
+var _clsx$2 = _interopRequireDefault$3(clsx);
+function _interopRequireDefault$3(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys$2(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$2(Object(source), true).forEach(function(key) {
+      _defineProperty$3(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _classCallCheck$3(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$3(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass$3(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties$3(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties$3(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _inherits$3(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass)
+    _setPrototypeOf$3(subClass, superClass);
+}
+function _setPrototypeOf$3(o, p) {
+  _setPrototypeOf$3 = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf$3(o, p);
+}
+function _createSuper$3(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct$3();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf$3(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf$3(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn$3(this, result);
+  };
+}
+function _possibleConstructorReturn$3(self, call) {
+  if (call && (_typeof$3(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized$3(self);
+}
+function _assertThisInitialized$3(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _isNativeReflectConstruct$3() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _getPrototypeOf$3(o) {
+  _getPrototypeOf$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf$3(o);
+}
+function _defineProperty$3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var GridItem = /* @__PURE__ */ function(_React$Component) {
+  _inherits$3(GridItem2, _React$Component);
+  var _super = _createSuper$3(GridItem2);
+  function GridItem2() {
+    var _this;
+    _classCallCheck$3(this, GridItem2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty$3(_assertThisInitialized$3(_this), "state", {
+      resizing: null,
+      dragging: null,
+      className: ""
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "elementRef", /* @__PURE__ */ _react.default.createRef());
+    _defineProperty$3(_assertThisInitialized$3(_this), "onDragStart", function(e, _ref) {
+      var node = _ref.node;
+      var _this$props = _this.props, onDragStart = _this$props.onDragStart, transformScale = _this$props.transformScale;
+      if (!onDragStart)
+        return;
+      var newPosition = {
+        top: 0,
+        left: 0
+      };
+      var offsetParent = node.offsetParent;
+      if (!offsetParent)
+        return;
+      var parentRect = offsetParent.getBoundingClientRect();
+      var clientRect = node.getBoundingClientRect();
+      var cLeft = clientRect.left / transformScale;
+      var pLeft = parentRect.left / transformScale;
+      var cTop = clientRect.top / transformScale;
+      var pTop = parentRect.top / transformScale;
+      newPosition.left = cLeft - pLeft + offsetParent.scrollLeft;
+      newPosition.top = cTop - pTop + offsetParent.scrollTop;
+      _this.setState({
+        dragging: newPosition
+      });
+      var _calcXY = (0, _calculateUtils$1.calcXY)(_this.getPositionParams(), newPosition.top, newPosition.left, _this.props.w, _this.props.h), x = _calcXY.x, y = _calcXY.y;
+      return onDragStart.call(_assertThisInitialized$3(_this), _this.props.i, x, y, {
+        e,
+        node,
+        newPosition
+      });
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "onDrag", function(e, _ref2) {
+      var node = _ref2.node, deltaX = _ref2.deltaX, deltaY = _ref2.deltaY;
+      var onDrag = _this.props.onDrag;
+      if (!onDrag)
+        return;
+      if (!_this.state.dragging) {
+        throw new Error("onDrag called before onDragStart.");
+      }
+      var top = _this.state.dragging.top + deltaY;
+      var left = _this.state.dragging.left + deltaX;
+      var _this$props2 = _this.props, isBounded = _this$props2.isBounded, i = _this$props2.i, w = _this$props2.w, h = _this$props2.h, containerWidth = _this$props2.containerWidth;
+      var positionParams = _this.getPositionParams();
+      if (isBounded) {
+        var offsetParent = node.offsetParent;
+        if (offsetParent) {
+          var _this$props3 = _this.props, margin = _this$props3.margin, rowHeight = _this$props3.rowHeight;
+          var bottomBoundary = offsetParent.clientHeight - (0, _calculateUtils$1.calcGridItemWHPx)(h, rowHeight, margin[1]);
+          top = (0, _calculateUtils$1.clamp)(top, 0, bottomBoundary);
+          var colWidth = (0, _calculateUtils$1.calcGridColWidth)(positionParams);
+          var rightBoundary = containerWidth - (0, _calculateUtils$1.calcGridItemWHPx)(w, colWidth, margin[0]);
+          left = (0, _calculateUtils$1.clamp)(left, 0, rightBoundary);
+        }
+      }
+      var newPosition = {
+        top,
+        left
+      };
+      _this.setState({
+        dragging: newPosition
+      });
+      var _calcXY2 = (0, _calculateUtils$1.calcXY)(positionParams, top, left, w, h), x = _calcXY2.x, y = _calcXY2.y;
+      return onDrag.call(_assertThisInitialized$3(_this), i, x, y, {
+        e,
+        node,
+        newPosition
+      });
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "onDragStop", function(e, _ref3) {
+      var node = _ref3.node;
+      var onDragStop = _this.props.onDragStop;
+      if (!onDragStop)
+        return;
+      if (!_this.state.dragging) {
+        throw new Error("onDragEnd called before onDragStart.");
+      }
+      var _this$props4 = _this.props, w = _this$props4.w, h = _this$props4.h, i = _this$props4.i;
+      var _this$state$dragging = _this.state.dragging, left = _this$state$dragging.left, top = _this$state$dragging.top;
+      var newPosition = {
+        top,
+        left
+      };
+      _this.setState({
+        dragging: null
+      });
+      var _calcXY3 = (0, _calculateUtils$1.calcXY)(_this.getPositionParams(), top, left, w, h), x = _calcXY3.x, y = _calcXY3.y;
+      return onDragStop.call(_assertThisInitialized$3(_this), i, x, y, {
+        e,
+        node,
+        newPosition
+      });
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "onResizeStop", function(e, callbackData) {
+      _this.onResizeHandler(e, callbackData, "onResizeStop");
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "onResizeStart", function(e, callbackData) {
+      _this.onResizeHandler(e, callbackData, "onResizeStart");
+    });
+    _defineProperty$3(_assertThisInitialized$3(_this), "onResize", function(e, callbackData) {
+      _this.onResizeHandler(e, callbackData, "onResize");
+    });
+    return _this;
+  }
+  _createClass$3(GridItem2, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      if (this.props.children !== nextProps.children)
+        return true;
+      if (this.props.droppingPosition !== nextProps.droppingPosition)
+        return true;
+      var oldPosition = (0, _calculateUtils$1.calcGridItemPosition)(this.getPositionParams(this.props), this.props.x, this.props.y, this.props.w, this.props.h, this.state);
+      var newPosition = (0, _calculateUtils$1.calcGridItemPosition)(this.getPositionParams(nextProps), nextProps.x, nextProps.y, nextProps.w, nextProps.h, nextState);
+      return !(0, _utils$3.fastPositionEqual)(oldPosition, newPosition) || this.props.useCSSTransforms !== nextProps.useCSSTransforms;
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.moveDroppingItem({});
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      this.moveDroppingItem(prevProps);
+    }
+  }, {
+    key: "moveDroppingItem",
+    value: function moveDroppingItem(prevProps) {
+      var droppingPosition = this.props.droppingPosition;
+      if (!droppingPosition)
+        return;
+      var node = this.elementRef.current;
+      if (!node)
+        return;
+      var prevDroppingPosition = prevProps.droppingPosition || {
+        left: 0,
+        top: 0
+      };
+      var dragging = this.state.dragging;
+      var shouldDrag = dragging && droppingPosition.left !== prevDroppingPosition.left || droppingPosition.top !== prevDroppingPosition.top;
+      if (!dragging) {
+        this.onDragStart(droppingPosition.e, {
+          node,
+          deltaX: droppingPosition.left,
+          deltaY: droppingPosition.top
+        });
+      } else if (shouldDrag) {
+        var deltaX = droppingPosition.left - dragging.left;
+        var deltaY = droppingPosition.top - dragging.top;
+        this.onDrag(droppingPosition.e, {
+          node,
+          deltaX,
+          deltaY
+        });
+      }
+    }
+  }, {
+    key: "getPositionParams",
+    value: function getPositionParams() {
+      var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.props;
+      return {
+        cols: props.cols,
+        containerPadding: props.containerPadding,
+        containerWidth: props.containerWidth,
+        margin: props.margin,
+        maxRows: props.maxRows,
+        rowHeight: props.rowHeight
+      };
+    }
+  }, {
+    key: "createStyle",
+    value: function createStyle(pos) {
+      var _this$props5 = this.props, usePercentages = _this$props5.usePercentages, containerWidth = _this$props5.containerWidth, useCSSTransforms = _this$props5.useCSSTransforms;
+      var style;
+      if (useCSSTransforms) {
+        style = (0, _utils$3.setTransform)(pos);
+      } else {
+        style = (0, _utils$3.setTopLeft)(pos);
+        if (usePercentages) {
+          style.left = (0, _utils$3.perc)(pos.left / containerWidth);
+          style.width = (0, _utils$3.perc)(pos.width / containerWidth);
+        }
+      }
+      return style;
+    }
+  }, {
+    key: "mixinDraggable",
+    value: function mixinDraggable(child, isDraggable) {
+      return /* @__PURE__ */ _react.default.createElement(_reactDraggable.DraggableCore, {
+        disabled: !isDraggable,
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop,
+        handle: this.props.handle,
+        cancel: ".react-resizable-handle" + (this.props.cancel ? "," + this.props.cancel : ""),
+        scale: this.props.transformScale,
+        nodeRef: this.elementRef
+      }, child);
+    }
+  }, {
+    key: "mixinResizable",
+    value: function mixinResizable(child, position, isResizable) {
+      var _this$props6 = this.props, cols = _this$props6.cols, x = _this$props6.x, minW2 = _this$props6.minW, minH2 = _this$props6.minH, maxW2 = _this$props6.maxW, maxH2 = _this$props6.maxH, transformScale = _this$props6.transformScale, resizeHandles = _this$props6.resizeHandles, resizeHandle = _this$props6.resizeHandle;
+      var positionParams = this.getPositionParams();
+      var maxWidth = (0, _calculateUtils$1.calcGridItemPosition)(positionParams, 0, 0, cols - x, 0).width;
+      var mins = (0, _calculateUtils$1.calcGridItemPosition)(positionParams, 0, 0, minW2, minH2);
+      var maxes = (0, _calculateUtils$1.calcGridItemPosition)(positionParams, 0, 0, maxW2, maxH2);
+      var minConstraints = [mins.width, mins.height];
+      var maxConstraints = [Math.min(maxes.width, maxWidth), Math.min(maxes.height, Infinity)];
+      return /* @__PURE__ */ _react.default.createElement(
+        _reactResizable.Resizable,
+        {
+          draggableOpts: {
+            disabled: !isResizable
+          },
+          className: isResizable ? void 0 : "react-resizable-hide",
+          width: position.width,
+          height: position.height,
+          minConstraints,
+          maxConstraints,
+          onResizeStop: this.onResizeStop,
+          onResizeStart: this.onResizeStart,
+          onResize: this.onResize,
+          transformScale,
+          resizeHandles,
+          handle: resizeHandle
+        },
+        child
+      );
+    }
+  }, {
+    key: "onResizeHandler",
+    value: function onResizeHandler(e, _ref4, handlerName) {
+      var node = _ref4.node, size = _ref4.size;
+      var handler = this.props[handlerName];
+      if (!handler)
+        return;
+      var _this$props7 = this.props, cols = _this$props7.cols, x = _this$props7.x, y = _this$props7.y, i = _this$props7.i, maxH2 = _this$props7.maxH, minH2 = _this$props7.minH;
+      var _this$props8 = this.props, minW2 = _this$props8.minW, maxW2 = _this$props8.maxW;
+      var _calcWH = (0, _calculateUtils$1.calcWH)(this.getPositionParams(), size.width, size.height, x, y), w = _calcWH.w, h = _calcWH.h;
+      minW2 = Math.max(minW2, 1);
+      maxW2 = Math.min(maxW2, cols - x);
+      w = (0, _calculateUtils$1.clamp)(w, minW2, maxW2);
+      h = (0, _calculateUtils$1.clamp)(h, minH2, maxH2);
+      this.setState({
+        resizing: handlerName === "onResizeStop" ? null : size
+      });
+      handler.call(this, i, w, h, {
+        e,
+        node,
+        size
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props9 = this.props, x = _this$props9.x, y = _this$props9.y, w = _this$props9.w, h = _this$props9.h, isDraggable = _this$props9.isDraggable, isResizable = _this$props9.isResizable, droppingPosition = _this$props9.droppingPosition, useCSSTransforms = _this$props9.useCSSTransforms;
+      var pos = (0, _calculateUtils$1.calcGridItemPosition)(this.getPositionParams(), x, y, w, h, this.state);
+      var child = _react.default.Children.only(this.props.children);
+      var newChild = /* @__PURE__ */ _react.default.cloneElement(child, {
+        ref: this.elementRef,
+        className: (0, _clsx$2.default)("react-grid-item", child.props.className, this.props.className, {
+          static: this.props.static,
+          resizing: Boolean(this.state.resizing),
+          "react-draggable": isDraggable,
+          "react-draggable-dragging": Boolean(this.state.dragging),
+          dropping: Boolean(droppingPosition),
+          cssTransforms: useCSSTransforms
+        }),
+        style: _objectSpread$2(_objectSpread$2(_objectSpread$2({}, this.props.style), child.props.style), this.createStyle(pos))
+      });
+      newChild = this.mixinResizable(newChild, pos, isResizable);
+      newChild = this.mixinDraggable(newChild, isDraggable);
+      return newChild;
+    }
+  }]);
+  return GridItem2;
+}(_react.default.Component);
+GridItem$1.default = GridItem;
+_defineProperty$3(GridItem, "propTypes", {
+  children: _propTypes$2.default.element,
+  cols: _propTypes$2.default.number.isRequired,
+  containerWidth: _propTypes$2.default.number.isRequired,
+  rowHeight: _propTypes$2.default.number.isRequired,
+  margin: _propTypes$2.default.array.isRequired,
+  maxRows: _propTypes$2.default.number.isRequired,
+  containerPadding: _propTypes$2.default.array.isRequired,
+  x: _propTypes$2.default.number.isRequired,
+  y: _propTypes$2.default.number.isRequired,
+  w: _propTypes$2.default.number.isRequired,
+  h: _propTypes$2.default.number.isRequired,
+  minW: function minW(props, propName) {
+    var value = props[propName];
+    if (typeof value !== "number")
+      return new Error("minWidth not Number");
+    if (value > props.w || value > props.maxW)
+      return new Error("minWidth larger than item width/maxWidth");
+  },
+  maxW: function maxW(props, propName) {
+    var value = props[propName];
+    if (typeof value !== "number")
+      return new Error("maxWidth not Number");
+    if (value < props.w || value < props.minW)
+      return new Error("maxWidth smaller than item width/minWidth");
+  },
+  minH: function minH(props, propName) {
+    var value = props[propName];
+    if (typeof value !== "number")
+      return new Error("minHeight not Number");
+    if (value > props.h || value > props.maxH)
+      return new Error("minHeight larger than item height/maxHeight");
+  },
+  maxH: function maxH(props, propName) {
+    var value = props[propName];
+    if (typeof value !== "number")
+      return new Error("maxHeight not Number");
+    if (value < props.h || value < props.minH)
+      return new Error("maxHeight smaller than item height/minHeight");
+  },
+  i: _propTypes$2.default.string.isRequired,
+  resizeHandles: _ReactGridLayoutPropTypes$1.resizeHandleAxesType,
+  resizeHandle: _ReactGridLayoutPropTypes$1.resizeHandleType,
+  onDragStop: _propTypes$2.default.func,
+  onDragStart: _propTypes$2.default.func,
+  onDrag: _propTypes$2.default.func,
+  onResizeStop: _propTypes$2.default.func,
+  onResizeStart: _propTypes$2.default.func,
+  onResize: _propTypes$2.default.func,
+  isDraggable: _propTypes$2.default.bool.isRequired,
+  isResizable: _propTypes$2.default.bool.isRequired,
+  isBounded: _propTypes$2.default.bool.isRequired,
+  static: _propTypes$2.default.bool,
+  useCSSTransforms: _propTypes$2.default.bool.isRequired,
+  transformScale: _propTypes$2.default.number,
+  className: _propTypes$2.default.string,
+  handle: _propTypes$2.default.string,
+  cancel: _propTypes$2.default.string,
+  droppingPosition: _propTypes$2.default.shape({
+    e: _propTypes$2.default.object.isRequired,
+    left: _propTypes$2.default.number.isRequired,
+    top: _propTypes$2.default.number.isRequired
+  })
+});
+_defineProperty$3(GridItem, "defaultProps", {
+  className: "",
+  cancel: "",
+  handle: "",
+  minH: 1,
+  minW: 1,
+  maxH: Infinity,
+  maxW: Infinity,
+  transformScale: 1
+});
+function _typeof$2(obj) {
+  "@babel/helpers - typeof";
+  return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof$2(obj);
+}
+Object.defineProperty(ReactGridLayout$1, "__esModule", {
+  value: true
+});
+ReactGridLayout$1.default = void 0;
+var React$2 = _interopRequireWildcard$2(React__default);
+var _lodash$1 = _interopRequireDefault$2(require$$0);
+var _clsx$1 = _interopRequireDefault$2(clsx);
+var _utils$2 = utils;
+var _calculateUtils = calculateUtils;
+var _GridItem = _interopRequireDefault$2(GridItem$1);
+var _ReactGridLayoutPropTypes = _interopRequireDefault$2(ReactGridLayoutPropTypes);
+function _interopRequireDefault$2(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function _getRequireWildcardCache$2(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache$2 = function _getRequireWildcardCache2(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard$2(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof$2(obj) !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache$2(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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.");
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr))
+    return _arrayLikeToArray(arr);
+}
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$1(Object(source), true).forEach(function(key) {
+      _defineProperty$2(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+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 _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 _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i == null)
+    return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _s, _e;
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i)
+        break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null)
+        _i["return"]();
+    } finally {
+      if (_d)
+        throw _e;
+    }
+  }
+  return _arr;
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _classCallCheck$2(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$2(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass$2(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties$2(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties$2(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _inherits$2(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass)
+    _setPrototypeOf$2(subClass, superClass);
+}
+function _setPrototypeOf$2(o, p) {
+  _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf$2(o, p);
+}
+function _createSuper$2(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct$2();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf$2(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf$2(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn$2(this, result);
+  };
+}
+function _possibleConstructorReturn$2(self, call) {
+  if (call && (_typeof$2(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized$2(self);
+}
+function _assertThisInitialized$2(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _isNativeReflectConstruct$2() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _getPrototypeOf$2(o) {
+  _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf$2(o);
+}
+function _defineProperty$2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var layoutClassName$1 = "react-grid-layout";
+var isFirefox = false;
+try {
+  isFirefox = /firefox/i.test(navigator.userAgent);
+} catch (e) {
+}
+var ReactGridLayout = /* @__PURE__ */ function(_React$Component) {
+  _inherits$2(ReactGridLayout2, _React$Component);
+  var _super = _createSuper$2(ReactGridLayout2);
+  function ReactGridLayout2() {
+    var _this;
+    _classCallCheck$2(this, ReactGridLayout2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty$2(_assertThisInitialized$2(_this), "state", {
+      activeDrag: null,
+      layout: (0, _utils$2.synchronizeLayoutWithChildren)(
+        _this.props.layout,
+        _this.props.children,
+        _this.props.cols,
+        (0, _utils$2.compactType)(_this.props),
+        _this.props.allowOverlap
+      ),
+      mounted: false,
+      oldDragItem: null,
+      oldLayout: null,
+      oldResizeItem: null,
+      droppingDOMNode: null,
+      children: []
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "dragEnterCounter", 0);
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDragStart", function(i, x, y, _ref) {
+      var e = _ref.e, node = _ref.node;
+      var layout2 = _this.state.layout;
+      var l = (0, _utils$2.getLayoutItem)(layout2, i);
+      if (!l)
+        return;
+      _this.setState({
+        oldDragItem: (0, _utils$2.cloneLayoutItem)(l),
+        oldLayout: layout2
+      });
+      return _this.props.onDragStart(layout2, l, l, null, e, node);
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDrag", function(i, x, y, _ref2) {
+      var e = _ref2.e, node = _ref2.node;
+      var oldDragItem = _this.state.oldDragItem;
+      var layout2 = _this.state.layout;
+      var _this$props = _this.props, cols = _this$props.cols, allowOverlap = _this$props.allowOverlap, preventCollision = _this$props.preventCollision;
+      var l = (0, _utils$2.getLayoutItem)(layout2, i);
+      if (!l)
+        return;
+      var placeholder = {
+        w: l.w,
+        h: l.h,
+        x: l.x,
+        y: l.y,
+        placeholder: true,
+        i
+      };
+      var isUserAction = true;
+      layout2 = (0, _utils$2.moveElement)(layout2, l, x, y, isUserAction, preventCollision, (0, _utils$2.compactType)(_this.props), cols, allowOverlap);
+      _this.props.onDrag(layout2, oldDragItem, l, placeholder, e, node);
+      _this.setState({
+        layout: allowOverlap ? layout2 : (0, _utils$2.compact)(layout2, (0, _utils$2.compactType)(_this.props), cols),
+        activeDrag: placeholder
+      });
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDragStop", function(i, x, y, _ref3) {
+      var e = _ref3.e, node = _ref3.node;
+      if (!_this.state.activeDrag)
+        return;
+      var oldDragItem = _this.state.oldDragItem;
+      var layout2 = _this.state.layout;
+      var _this$props2 = _this.props, cols = _this$props2.cols, preventCollision = _this$props2.preventCollision, allowOverlap = _this$props2.allowOverlap;
+      var l = (0, _utils$2.getLayoutItem)(layout2, i);
+      if (!l)
+        return;
+      var isUserAction = true;
+      layout2 = (0, _utils$2.moveElement)(layout2, l, x, y, isUserAction, preventCollision, (0, _utils$2.compactType)(_this.props), cols, allowOverlap);
+      _this.props.onDragStop(layout2, oldDragItem, l, null, e, node);
+      var newLayout = allowOverlap ? layout2 : (0, _utils$2.compact)(layout2, (0, _utils$2.compactType)(_this.props), cols);
+      var oldLayout = _this.state.oldLayout;
+      _this.setState({
+        activeDrag: null,
+        layout: newLayout,
+        oldDragItem: null,
+        oldLayout: null
+      });
+      _this.onLayoutMaybeChanged(newLayout, oldLayout);
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onResizeStart", function(i, w, h, _ref4) {
+      var e = _ref4.e, node = _ref4.node;
+      var layout2 = _this.state.layout;
+      var l = (0, _utils$2.getLayoutItem)(layout2, i);
+      if (!l)
+        return;
+      _this.setState({
+        oldResizeItem: (0, _utils$2.cloneLayoutItem)(l),
+        oldLayout: _this.state.layout
+      });
+      _this.props.onResizeStart(layout2, l, l, null, e, node);
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onResize", function(i, w, h, _ref5) {
+      var e = _ref5.e, node = _ref5.node;
+      var _this$state = _this.state, layout2 = _this$state.layout, oldResizeItem = _this$state.oldResizeItem;
+      var _this$props3 = _this.props, cols = _this$props3.cols, preventCollision = _this$props3.preventCollision, allowOverlap = _this$props3.allowOverlap;
+      var _withLayoutItem = (0, _utils$2.withLayoutItem)(layout2, i, function(l2) {
+        var hasCollisions;
+        if (preventCollision && !allowOverlap) {
+          var collisions = (0, _utils$2.getAllCollisions)(layout2, _objectSpread$1(_objectSpread$1({}, l2), {}, {
+            w,
+            h
+          })).filter(function(layoutItem) {
+            return layoutItem.i !== l2.i;
+          });
+          hasCollisions = collisions.length > 0;
+          if (hasCollisions) {
+            var leastX = Infinity, leastY = Infinity;
+            collisions.forEach(function(layoutItem) {
+              if (layoutItem.x > l2.x)
+                leastX = Math.min(leastX, layoutItem.x);
+              if (layoutItem.y > l2.y)
+                leastY = Math.min(leastY, layoutItem.y);
+            });
+            if (Number.isFinite(leastX))
+              l2.w = leastX - l2.x;
+            if (Number.isFinite(leastY))
+              l2.h = leastY - l2.y;
+          }
+        }
+        if (!hasCollisions) {
+          l2.w = w;
+          l2.h = h;
+        }
+        return l2;
+      }), _withLayoutItem2 = _slicedToArray(_withLayoutItem, 2), newLayout = _withLayoutItem2[0], l = _withLayoutItem2[1];
+      if (!l)
+        return;
+      var placeholder = {
+        w: l.w,
+        h: l.h,
+        x: l.x,
+        y: l.y,
+        static: true,
+        i
+      };
+      _this.props.onResize(newLayout, oldResizeItem, l, placeholder, e, node);
+      _this.setState({
+        layout: allowOverlap ? newLayout : (0, _utils$2.compact)(newLayout, (0, _utils$2.compactType)(_this.props), cols),
+        activeDrag: placeholder
+      });
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onResizeStop", function(i, w, h, _ref6) {
+      var e = _ref6.e, node = _ref6.node;
+      var _this$state2 = _this.state, layout2 = _this$state2.layout, oldResizeItem = _this$state2.oldResizeItem;
+      var _this$props4 = _this.props, cols = _this$props4.cols, allowOverlap = _this$props4.allowOverlap;
+      var l = (0, _utils$2.getLayoutItem)(layout2, i);
+      _this.props.onResizeStop(layout2, oldResizeItem, l, null, e, node);
+      var newLayout = allowOverlap ? layout2 : (0, _utils$2.compact)(layout2, (0, _utils$2.compactType)(_this.props), cols);
+      var oldLayout = _this.state.oldLayout;
+      _this.setState({
+        activeDrag: null,
+        layout: newLayout,
+        oldResizeItem: null,
+        oldLayout: null
+      });
+      _this.onLayoutMaybeChanged(newLayout, oldLayout);
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDragOver", function(e) {
+      var _e$nativeEvent$target;
+      e.preventDefault();
+      e.stopPropagation();
+      if (isFirefox && !((_e$nativeEvent$target = e.nativeEvent.target) !== null && _e$nativeEvent$target !== void 0 && _e$nativeEvent$target.classList.contains(layoutClassName$1))) {
+        return false;
+      }
+      var _this$props5 = _this.props, droppingItem = _this$props5.droppingItem, onDropDragOver = _this$props5.onDropDragOver, margin = _this$props5.margin, cols = _this$props5.cols, rowHeight = _this$props5.rowHeight, maxRows = _this$props5.maxRows, width = _this$props5.width, containerPadding = _this$props5.containerPadding, transformScale = _this$props5.transformScale;
+      var onDragOverResult = onDropDragOver === null || onDropDragOver === void 0 ? void 0 : onDropDragOver(e);
+      if (onDragOverResult === false) {
+        if (_this.state.droppingDOMNode) {
+          _this.removeDroppingPlaceholder();
+        }
+        return false;
+      }
+      var finalDroppingItem = _objectSpread$1(_objectSpread$1({}, droppingItem), onDragOverResult);
+      var layout2 = _this.state.layout;
+      var _e$nativeEvent = e.nativeEvent, layerX = _e$nativeEvent.layerX, layerY = _e$nativeEvent.layerY;
+      var droppingPosition = {
+        left: layerX / transformScale,
+        top: layerY / transformScale,
+        e
+      };
+      if (!_this.state.droppingDOMNode) {
+        var positionParams = {
+          cols,
+          margin,
+          maxRows,
+          rowHeight,
+          containerWidth: width,
+          containerPadding: containerPadding || margin
+        };
+        var calculatedPosition = (0, _calculateUtils.calcXY)(positionParams, layerY, layerX, finalDroppingItem.w, finalDroppingItem.h);
+        _this.setState({
+          droppingDOMNode: /* @__PURE__ */ React$2.createElement("div", {
+            key: finalDroppingItem.i
+          }),
+          droppingPosition,
+          layout: [].concat(_toConsumableArray(layout2), [_objectSpread$1(_objectSpread$1({}, finalDroppingItem), {}, {
+            x: calculatedPosition.x,
+            y: calculatedPosition.y,
+            static: false,
+            isDraggable: true
+          })])
+        });
+      } else if (_this.state.droppingPosition) {
+        var _this$state$droppingP = _this.state.droppingPosition, left = _this$state$droppingP.left, top = _this$state$droppingP.top;
+        var shouldUpdatePosition = left != layerX || top != layerY;
+        if (shouldUpdatePosition) {
+          _this.setState({
+            droppingPosition
+          });
+        }
+      }
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "removeDroppingPlaceholder", function() {
+      var _this$props6 = _this.props, droppingItem = _this$props6.droppingItem, cols = _this$props6.cols;
+      var layout2 = _this.state.layout;
+      var newLayout = (0, _utils$2.compact)(layout2.filter(function(l) {
+        return l.i !== droppingItem.i;
+      }), (0, _utils$2.compactType)(_this.props), cols);
+      _this.setState({
+        layout: newLayout,
+        droppingDOMNode: null,
+        activeDrag: null,
+        droppingPosition: void 0
+      });
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDragLeave", function(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      _this.dragEnterCounter--;
+      if (_this.dragEnterCounter === 0) {
+        _this.removeDroppingPlaceholder();
+      }
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDragEnter", function(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      _this.dragEnterCounter++;
+    });
+    _defineProperty$2(_assertThisInitialized$2(_this), "onDrop", function(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      var droppingItem = _this.props.droppingItem;
+      var layout2 = _this.state.layout;
+      var item = layout2.find(function(l) {
+        return l.i === droppingItem.i;
+      });
+      _this.dragEnterCounter = 0;
+      _this.removeDroppingPlaceholder();
+      _this.props.onDrop(layout2, item, e);
+    });
+    return _this;
+  }
+  _createClass$2(ReactGridLayout2, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.setState({
+        mounted: true
+      });
+      this.onLayoutMaybeChanged(this.state.layout, this.props.layout);
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      return this.props.children !== nextProps.children || !(0, _utils$2.fastRGLPropsEqual)(this.props, nextProps, _lodash$1.default) || this.state.activeDrag !== nextState.activeDrag || this.state.mounted !== nextState.mounted || this.state.droppingPosition !== nextState.droppingPosition;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (!this.state.activeDrag) {
+        var newLayout = this.state.layout;
+        var oldLayout = prevState.layout;
+        this.onLayoutMaybeChanged(newLayout, oldLayout);
+      }
+    }
+  }, {
+    key: "containerHeight",
+    value: function containerHeight() {
+      if (!this.props.autoSize)
+        return;
+      var nbRow = (0, _utils$2.bottom)(this.state.layout);
+      var containerPaddingY = this.props.containerPadding ? this.props.containerPadding[1] : this.props.margin[1];
+      return nbRow * this.props.rowHeight + (nbRow - 1) * this.props.margin[1] + containerPaddingY * 2 + "px";
+    }
+  }, {
+    key: "onLayoutMaybeChanged",
+    value: function onLayoutMaybeChanged(newLayout, oldLayout) {
+      if (!oldLayout)
+        oldLayout = this.state.layout;
+      if (!(0, _lodash$1.default)(oldLayout, newLayout)) {
+        this.props.onLayoutChange(newLayout);
+      }
+    }
+  }, {
+    key: "placeholder",
+    value: function placeholder() {
+      var activeDrag = this.state.activeDrag;
+      if (!activeDrag)
+        return null;
+      var _this$props7 = this.props, width = _this$props7.width, cols = _this$props7.cols, margin = _this$props7.margin, containerPadding = _this$props7.containerPadding, rowHeight = _this$props7.rowHeight, maxRows = _this$props7.maxRows, useCSSTransforms = _this$props7.useCSSTransforms, transformScale = _this$props7.transformScale;
+      return /* @__PURE__ */ React$2.createElement(_GridItem.default, {
+        w: activeDrag.w,
+        h: activeDrag.h,
+        x: activeDrag.x,
+        y: activeDrag.y,
+        i: activeDrag.i,
+        className: "react-grid-placeholder",
+        containerWidth: width,
+        cols,
+        margin,
+        containerPadding: containerPadding || margin,
+        maxRows,
+        rowHeight,
+        isDraggable: false,
+        isResizable: false,
+        isBounded: false,
+        useCSSTransforms,
+        transformScale
+      }, /* @__PURE__ */ React$2.createElement("div", null));
+    }
+  }, {
+    key: "processGridItem",
+    value: function processGridItem(child, isDroppingItem) {
+      if (!child || !child.key)
+        return;
+      var l = (0, _utils$2.getLayoutItem)(this.state.layout, String(child.key));
+      if (!l)
+        return null;
+      var _this$props8 = this.props, width = _this$props8.width, cols = _this$props8.cols, margin = _this$props8.margin, containerPadding = _this$props8.containerPadding, rowHeight = _this$props8.rowHeight, maxRows = _this$props8.maxRows, isDraggable = _this$props8.isDraggable, isResizable = _this$props8.isResizable, isBounded = _this$props8.isBounded, useCSSTransforms = _this$props8.useCSSTransforms, transformScale = _this$props8.transformScale, draggableCancel = _this$props8.draggableCancel, draggableHandle = _this$props8.draggableHandle, resizeHandles = _this$props8.resizeHandles, resizeHandle = _this$props8.resizeHandle;
+      var _this$state3 = this.state, mounted = _this$state3.mounted, droppingPosition = _this$state3.droppingPosition;
+      var draggable = typeof l.isDraggable === "boolean" ? l.isDraggable : !l.static && isDraggable;
+      var resizable = typeof l.isResizable === "boolean" ? l.isResizable : !l.static && isResizable;
+      var resizeHandlesOptions = l.resizeHandles || resizeHandles;
+      var bounded = draggable && isBounded && l.isBounded !== false;
+      return /* @__PURE__ */ React$2.createElement(_GridItem.default, {
+        containerWidth: width,
+        cols,
+        margin,
+        containerPadding: containerPadding || margin,
+        maxRows,
+        rowHeight,
+        cancel: draggableCancel,
+        handle: draggableHandle,
+        onDragStop: this.onDragStop,
+        onDragStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onResizeStart: this.onResizeStart,
+        onResize: this.onResize,
+        onResizeStop: this.onResizeStop,
+        isDraggable: draggable,
+        isResizable: resizable,
+        isBounded: bounded,
+        useCSSTransforms: useCSSTransforms && mounted,
+        usePercentages: !mounted,
+        transformScale,
+        w: l.w,
+        h: l.h,
+        x: l.x,
+        y: l.y,
+        i: l.i,
+        minH: l.minH,
+        minW: l.minW,
+        maxH: l.maxH,
+        maxW: l.maxW,
+        static: l.static,
+        droppingPosition: isDroppingItem ? droppingPosition : void 0,
+        resizeHandles: resizeHandlesOptions,
+        resizeHandle
+      }, child);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props9 = this.props, className = _this$props9.className, style = _this$props9.style, isDroppable = _this$props9.isDroppable, innerRef = _this$props9.innerRef;
+      var mergedClassName = (0, _clsx$1.default)(layoutClassName$1, className);
+      var mergedStyle = _objectSpread$1({
+        height: this.containerHeight()
+      }, style);
+      return /* @__PURE__ */ React$2.createElement("div", {
+        ref: innerRef,
+        className: mergedClassName,
+        style: mergedStyle,
+        onDrop: isDroppable ? this.onDrop : _utils$2.noop,
+        onDragLeave: isDroppable ? this.onDragLeave : _utils$2.noop,
+        onDragEnter: isDroppable ? this.onDragEnter : _utils$2.noop,
+        onDragOver: isDroppable ? this.onDragOver : _utils$2.noop
+      }, React$2.Children.map(this.props.children, function(child) {
+        return _this2.processGridItem(child);
+      }), isDroppable && this.state.droppingDOMNode && this.processGridItem(this.state.droppingDOMNode, true), this.placeholder());
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var newLayoutBase;
+      if (prevState.activeDrag) {
+        return null;
+      }
+      if (!(0, _lodash$1.default)(nextProps.layout, prevState.propsLayout) || nextProps.compactType !== prevState.compactType) {
+        newLayoutBase = nextProps.layout;
+      } else if (!(0, _utils$2.childrenEqual)(nextProps.children, prevState.children)) {
+        newLayoutBase = prevState.layout;
+      }
+      if (newLayoutBase) {
+        var newLayout = (0, _utils$2.synchronizeLayoutWithChildren)(newLayoutBase, nextProps.children, nextProps.cols, (0, _utils$2.compactType)(nextProps), nextProps.allowOverlap);
+        return {
+          layout: newLayout,
+          compactType: nextProps.compactType,
+          children: nextProps.children,
+          propsLayout: nextProps.layout
+        };
+      }
+      return null;
+    }
+  }]);
+  return ReactGridLayout2;
+}(React$2.Component);
+ReactGridLayout$1.default = ReactGridLayout;
+_defineProperty$2(ReactGridLayout, "displayName", "ReactGridLayout");
+_defineProperty$2(ReactGridLayout, "propTypes", _ReactGridLayoutPropTypes.default);
+_defineProperty$2(ReactGridLayout, "defaultProps", {
+  autoSize: true,
+  cols: 12,
+  className: "",
+  style: {},
+  draggableHandle: "",
+  draggableCancel: "",
+  containerPadding: null,
+  rowHeight: 150,
+  maxRows: Infinity,
+  layout: [],
+  margin: [10, 10],
+  isBounded: false,
+  isDraggable: true,
+  isResizable: true,
+  allowOverlap: false,
+  isDroppable: false,
+  useCSSTransforms: true,
+  transformScale: 1,
+  verticalCompact: true,
+  compactType: "vertical",
+  preventCollision: false,
+  droppingItem: {
+    i: "__dropping-elem__",
+    h: 1,
+    w: 1
+  },
+  resizeHandles: ["se"],
+  onLayoutChange: _utils$2.noop,
+  onDragStart: _utils$2.noop,
+  onDrag: _utils$2.noop,
+  onDragStop: _utils$2.noop,
+  onResizeStart: _utils$2.noop,
+  onResize: _utils$2.noop,
+  onResizeStop: _utils$2.noop,
+  onDrop: _utils$2.noop,
+  onDropDragOver: _utils$2.noop
+});
+var ResponsiveReactGridLayout$1 = {};
+var responsiveUtils = {};
+Object.defineProperty(responsiveUtils, "__esModule", {
+  value: true
+});
+responsiveUtils.findOrGenerateResponsiveLayout = findOrGenerateResponsiveLayout;
+responsiveUtils.getBreakpointFromWidth = getBreakpointFromWidth;
+responsiveUtils.getColsFromBreakpoint = getColsFromBreakpoint;
+responsiveUtils.sortBreakpoints = sortBreakpoints;
+var _utils$1 = utils;
+function getBreakpointFromWidth(breakpoints, width) {
+  var sorted = sortBreakpoints(breakpoints);
+  var matching = sorted[0];
+  for (var i = 1, len = sorted.length; i < len; i++) {
+    var breakpointName = sorted[i];
+    if (width > breakpoints[breakpointName])
+      matching = breakpointName;
+  }
+  return matching;
+}
+function getColsFromBreakpoint(breakpoint, cols) {
+  if (!cols[breakpoint]) {
+    throw new Error("ResponsiveReactGridLayout: `cols` entry for breakpoint " + breakpoint + " is missing!");
+  }
+  return cols[breakpoint];
+}
+function findOrGenerateResponsiveLayout(layouts2, breakpoints, breakpoint, lastBreakpoint, cols, compactType) {
+  if (layouts2[breakpoint])
+    return (0, _utils$1.cloneLayout)(layouts2[breakpoint]);
+  var layout2 = layouts2[lastBreakpoint];
+  var breakpointsSorted = sortBreakpoints(breakpoints);
+  var breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));
+  for (var i = 0, len = breakpointsAbove.length; i < len; i++) {
+    var b = breakpointsAbove[i];
+    if (layouts2[b]) {
+      layout2 = layouts2[b];
+      break;
+    }
+  }
+  layout2 = (0, _utils$1.cloneLayout)(layout2 || []);
+  return (0, _utils$1.compact)((0, _utils$1.correctBounds)(layout2, {
+    cols
+  }), compactType, cols);
+}
+function sortBreakpoints(breakpoints) {
+  var keys = Object.keys(breakpoints);
+  return keys.sort(function(a, b) {
+    return breakpoints[a] - breakpoints[b];
+  });
+}
+function _typeof$1(obj) {
+  "@babel/helpers - typeof";
+  return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof$1(obj);
+}
+Object.defineProperty(ResponsiveReactGridLayout$1, "__esModule", {
+  value: true
+});
+ResponsiveReactGridLayout$1.default = void 0;
+var React$1 = _interopRequireWildcard$1(React__default);
+var _propTypes$1 = _interopRequireDefault$1(require$$1);
+var _lodash = _interopRequireDefault$1(require$$0);
+var _utils = utils;
+var _responsiveUtils = responsiveUtils;
+var _ReactGridLayout = _interopRequireDefault$1(ReactGridLayout$1);
+var _excluded$1 = ["breakpoint", "breakpoints", "cols", "layouts", "margin", "containerPadding", "onBreakpointChange", "onLayoutChange", "onWidthChange"];
+function _interopRequireDefault$1(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function _getRequireWildcardCache$1(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache$1 = function _getRequireWildcardCache2(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard$1(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof$1(obj) !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache$1(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _extends$1() {
+  _extends$1 = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends$1.apply(this, arguments);
+}
+function _objectWithoutProperties$1(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _objectWithoutPropertiesLoose$1(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0)
+        continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key))
+        continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _objectWithoutPropertiesLoose$1(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty$1(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _classCallCheck$1(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$1(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass$1(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties$1(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties$1(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _inherits$1(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass)
+    _setPrototypeOf$1(subClass, superClass);
+}
+function _setPrototypeOf$1(o, p) {
+  _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf$1(o, p);
+}
+function _createSuper$1(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct$1();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf$1(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf$1(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn$1(this, result);
+  };
+}
+function _possibleConstructorReturn$1(self, call) {
+  if (call && (_typeof$1(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized$1(self);
+}
+function _assertThisInitialized$1(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _isNativeReflectConstruct$1() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _getPrototypeOf$1(o) {
+  _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf$1(o);
+}
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var type = function type2(obj) {
+  return Object.prototype.toString.call(obj);
+};
+function getIndentationValue(param, breakpoint) {
+  if (param == null)
+    return null;
+  return Array.isArray(param) ? param : param[breakpoint];
+}
+var ResponsiveReactGridLayout = /* @__PURE__ */ function(_React$Component) {
+  _inherits$1(ResponsiveReactGridLayout2, _React$Component);
+  var _super = _createSuper$1(ResponsiveReactGridLayout2);
+  function ResponsiveReactGridLayout2() {
+    var _this;
+    _classCallCheck$1(this, ResponsiveReactGridLayout2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty$1(_assertThisInitialized$1(_this), "state", _this.generateInitialState());
+    _defineProperty$1(_assertThisInitialized$1(_this), "onLayoutChange", function(layout2) {
+      _this.props.onLayoutChange(layout2, _objectSpread(_objectSpread({}, _this.props.layouts), {}, _defineProperty$1({}, _this.state.breakpoint, layout2)));
+    });
+    return _this;
+  }
+  _createClass$1(ResponsiveReactGridLayout2, [{
+    key: "generateInitialState",
+    value: function generateInitialState() {
+      var _this$props = this.props, width = _this$props.width, breakpoints = _this$props.breakpoints, layouts2 = _this$props.layouts, cols = _this$props.cols;
+      var breakpoint = (0, _responsiveUtils.getBreakpointFromWidth)(breakpoints, width);
+      var colNo = (0, _responsiveUtils.getColsFromBreakpoint)(breakpoint, cols);
+      var compactType = this.props.verticalCompact === false ? null : this.props.compactType;
+      var initialLayout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(layouts2, breakpoints, breakpoint, breakpoint, colNo, compactType);
+      return {
+        layout: initialLayout,
+        breakpoint,
+        cols: colNo
+      };
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (this.props.width != prevProps.width || this.props.breakpoint !== prevProps.breakpoint || !(0, _lodash.default)(this.props.breakpoints, prevProps.breakpoints) || !(0, _lodash.default)(this.props.cols, prevProps.cols)) {
+        this.onWidthChange(prevProps);
+      }
+    }
+  }, {
+    key: "onWidthChange",
+    value: function onWidthChange(prevProps) {
+      var _this$props2 = this.props, breakpoints = _this$props2.breakpoints, cols = _this$props2.cols, layouts2 = _this$props2.layouts, compactType = _this$props2.compactType;
+      var newBreakpoint = this.props.breakpoint || (0, _responsiveUtils.getBreakpointFromWidth)(this.props.breakpoints, this.props.width);
+      var lastBreakpoint = this.state.breakpoint;
+      var newCols = (0, _responsiveUtils.getColsFromBreakpoint)(newBreakpoint, cols);
+      var newLayouts = _objectSpread({}, layouts2);
+      if (lastBreakpoint !== newBreakpoint || prevProps.breakpoints !== breakpoints || prevProps.cols !== cols) {
+        if (!(lastBreakpoint in newLayouts))
+          newLayouts[lastBreakpoint] = (0, _utils.cloneLayout)(this.state.layout);
+        var layout2 = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(newLayouts, breakpoints, newBreakpoint, lastBreakpoint, newCols, compactType);
+        layout2 = (0, _utils.synchronizeLayoutWithChildren)(layout2, this.props.children, newCols, compactType, this.props.allowOverlap);
+        newLayouts[newBreakpoint] = layout2;
+        this.props.onLayoutChange(layout2, newLayouts);
+        this.props.onBreakpointChange(newBreakpoint, newCols);
+        this.setState({
+          breakpoint: newBreakpoint,
+          layout: layout2,
+          cols: newCols
+        });
+      }
+      var margin = getIndentationValue(this.props.margin, newBreakpoint);
+      var containerPadding = getIndentationValue(this.props.containerPadding, newBreakpoint);
+      this.props.onWidthChange(this.props.width, margin, newCols, containerPadding);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props3 = this.props;
+      _this$props3.breakpoint;
+      _this$props3.breakpoints;
+      _this$props3.cols;
+      _this$props3.layouts;
+      var margin = _this$props3.margin, containerPadding = _this$props3.containerPadding;
+      _this$props3.onBreakpointChange;
+      _this$props3.onLayoutChange;
+      _this$props3.onWidthChange;
+      var other = _objectWithoutProperties$1(_this$props3, _excluded$1);
+      return /* @__PURE__ */ React$1.createElement(_ReactGridLayout.default, _extends$1({}, other, {
+        margin: getIndentationValue(margin, this.state.breakpoint),
+        containerPadding: getIndentationValue(containerPadding, this.state.breakpoint),
+        onLayoutChange: this.onLayoutChange,
+        layout: this.state.layout,
+        cols: this.state.cols
+      }));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (!(0, _lodash.default)(nextProps.layouts, prevState.layouts)) {
+        var breakpoint = prevState.breakpoint, _cols = prevState.cols;
+        var newLayout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(nextProps.layouts, nextProps.breakpoints, breakpoint, breakpoint, _cols, nextProps.compactType);
+        return {
+          layout: newLayout,
+          layouts: nextProps.layouts
+        };
+      }
+      return null;
+    }
+  }]);
+  return ResponsiveReactGridLayout2;
+}(React$1.Component);
+ResponsiveReactGridLayout$1.default = ResponsiveReactGridLayout;
+_defineProperty$1(ResponsiveReactGridLayout, "propTypes", {
+  breakpoint: _propTypes$1.default.string,
+  breakpoints: _propTypes$1.default.object,
+  allowOverlap: _propTypes$1.default.bool,
+  cols: _propTypes$1.default.object,
+  margin: _propTypes$1.default.oneOfType([_propTypes$1.default.array, _propTypes$1.default.object]),
+  containerPadding: _propTypes$1.default.oneOfType([_propTypes$1.default.array, _propTypes$1.default.object]),
+  layouts: function layouts(props, propName) {
+    if (type(props[propName]) !== "[object Object]") {
+      throw new Error("Layout property must be an object. Received: " + type(props[propName]));
+    }
+    Object.keys(props[propName]).forEach(function(key) {
+      if (!(key in props.breakpoints)) {
+        throw new Error("Each key in layouts must align with a key in breakpoints.");
+      }
+      (0, _utils.validateLayout)(props.layouts[key], "layouts." + key);
+    });
+  },
+  width: _propTypes$1.default.number.isRequired,
+  onBreakpointChange: _propTypes$1.default.func,
+  onLayoutChange: _propTypes$1.default.func,
+  onWidthChange: _propTypes$1.default.func
+});
+_defineProperty$1(ResponsiveReactGridLayout, "defaultProps", {
+  breakpoints: {
+    lg: 1200,
+    md: 996,
+    sm: 768,
+    xs: 480,
+    xxs: 0
+  },
+  cols: {
+    lg: 12,
+    md: 10,
+    sm: 6,
+    xs: 4,
+    xxs: 2
+  },
+  containerPadding: {
+    lg: null,
+    md: null,
+    sm: null,
+    xs: null,
+    xxs: null
+  },
+  layouts: {},
+  margin: [10, 10],
+  allowOverlap: false,
+  onBreakpointChange: _utils.noop,
+  onLayoutChange: _utils.noop,
+  onWidthChange: _utils.noop
+});
+var WidthProvider = {};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+Object.defineProperty(WidthProvider, "__esModule", {
+  value: true
+});
+WidthProvider.default = WidthProvideRGL;
+var React = _interopRequireWildcard(React__default);
+var _propTypes = _interopRequireDefault(require$$1);
+var _clsx = _interopRequireDefault(clsx);
+var _excluded = ["measureBeforeMount"];
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0)
+        continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key))
+        continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass)
+    _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var layoutClassName = "react-grid-layout";
+function WidthProvideRGL(ComposedComponent) {
+  var _class;
+  return _class = /* @__PURE__ */ function(_React$Component) {
+    _inherits(WidthProvider2, _React$Component);
+    var _super = _createSuper(WidthProvider2);
+    function WidthProvider2() {
+      var _this;
+      _classCallCheck(this, WidthProvider2);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        width: 1280
+      });
+      _defineProperty(_assertThisInitialized(_this), "elementRef", /* @__PURE__ */ React.createRef());
+      _defineProperty(_assertThisInitialized(_this), "mounted", false);
+      _defineProperty(_assertThisInitialized(_this), "onWindowResize", function() {
+        if (!_this.mounted)
+          return;
+        var node = _this.elementRef.current;
+        if (node instanceof HTMLElement && node.offsetWidth) {
+          _this.setState({
+            width: node.offsetWidth
+          });
+        }
+      });
+      return _this;
+    }
+    _createClass(WidthProvider2, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.mounted = true;
+        window.addEventListener("resize", this.onWindowResize);
+        this.onWindowResize();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.mounted = false;
+        window.removeEventListener("resize", this.onWindowResize);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props, measureBeforeMount = _this$props.measureBeforeMount, rest = _objectWithoutProperties(_this$props, _excluded);
+        if (measureBeforeMount && !this.mounted) {
+          return /* @__PURE__ */ React.createElement("div", {
+            className: (0, _clsx.default)(this.props.className, layoutClassName),
+            style: this.props.style,
+            ref: this.elementRef
+          });
+        }
+        return /* @__PURE__ */ React.createElement(ComposedComponent, _extends({
+          innerRef: this.elementRef
+        }, rest, this.state));
+      }
+    }]);
+    return WidthProvider2;
+  }(React.Component), _defineProperty(_class, "defaultProps", {
+    measureBeforeMount: false
+  }), _defineProperty(_class, "propTypes", {
+    measureBeforeMount: _propTypes.default.bool
+  }), _class;
+}
+(function(module) {
+  module.exports = ReactGridLayout$1.default;
+  module.exports.utils = utils;
+  module.exports.Responsive = ResponsiveReactGridLayout$1.default;
+  module.exports.Responsive.utils = responsiveUtils;
+  module.exports.WidthProvider = WidthProvider.default;
+})(reactGridLayout);
+const styles = "";
+export {
+  createAnimation as c,
+  fastRGLPropsEqual as f,
+  parseLengthAndUnit as p,
+  reactGridLayout as r
+};