@m4l/components 0.1.35 → 0.1.36

package/dist/utils/index.9dce2e2f.js

@@ -0,0 +1,1013 @@
+import React__default from "react";
+import require$$0 from "lodash.isequal";
+import { f as fastRGLPropsEqual$1 } from "../node_modules.e0b84fac.js";
+var domFns = {};
+var shims = {};
+Object.defineProperty(shims, "__esModule", {
+  value: true
+});
+shims.dontSetMe = dontSetMe;
+shims.findInArray = findInArray;
+shims.int = int;
+shims.isFunction = isFunction;
+shims.isNum = isNum;
+function findInArray(array, callback) {
+  for (var i = 0, length = array.length; i < length; i++) {
+    if (callback.apply(callback, [array[i], i, array]))
+      return array[i];
+  }
+}
+function isFunction(func) {
+  return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+}
+function isNum(num) {
+  return typeof num === "number" && !isNaN(num);
+}
+function int(a) {
+  return parseInt(a, 10);
+}
+function dontSetMe(props, propName, componentName) {
+  if (props[propName]) {
+    return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
+  }
+}
+var getPrefix$1 = {};
+Object.defineProperty(getPrefix$1, "__esModule", {
+  value: true
+});
+getPrefix$1.browserPrefixToKey = browserPrefixToKey;
+getPrefix$1.browserPrefixToStyle = browserPrefixToStyle;
+getPrefix$1.default = void 0;
+getPrefix$1.getPrefix = getPrefix;
+var prefixes = ["Moz", "Webkit", "O", "ms"];
+function getPrefix() {
+  var _window$document, _window$document$docu;
+  var prop = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window === "undefined")
+    return "";
+  var style = (_window$document = window.document) === null || _window$document === void 0 ? void 0 : (_window$document$docu = _window$document.documentElement) === null || _window$document$docu === void 0 ? void 0 : _window$document$docu.style;
+  if (!style)
+    return "";
+  if (prop in style)
+    return "";
+  for (var i = 0; i < prefixes.length; i++) {
+    if (browserPrefixToKey(prop, prefixes[i]) in style)
+      return prefixes[i];
+  }
+  return "";
+}
+function browserPrefixToKey(prop, prefix) {
+  return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
+}
+function browserPrefixToStyle(prop, prefix) {
+  return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
+}
+function kebabToTitleCase(str) {
+  var out = "";
+  var shouldCapitalize = true;
+  for (var i = 0; i < str.length; i++) {
+    if (shouldCapitalize) {
+      out += str[i].toUpperCase();
+      shouldCapitalize = false;
+    } else if (str[i] === "-") {
+      shouldCapitalize = true;
+    } else {
+      out += str[i];
+    }
+  }
+  return out;
+}
+var _default = getPrefix();
+getPrefix$1.default = _default;
+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(domFns, "__esModule", {
+  value: true
+});
+domFns.addClassName = addClassName;
+domFns.addEvent = addEvent;
+domFns.addUserSelectStyles = addUserSelectStyles;
+domFns.createCSSTransform = createCSSTransform;
+domFns.createSVGTransform = createSVGTransform;
+domFns.getTouch = getTouch;
+domFns.getTouchIdentifier = getTouchIdentifier;
+domFns.getTranslation = getTranslation;
+domFns.innerHeight = innerHeight;
+domFns.innerWidth = innerWidth;
+domFns.matchesSelector = matchesSelector;
+domFns.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
+domFns.offsetXYFromParent = offsetXYFromParent;
+domFns.outerHeight = outerHeight;
+domFns.outerWidth = outerWidth;
+domFns.removeClassName = removeClassName;
+domFns.removeEvent = removeEvent;
+domFns.removeUserSelectStyles = removeUserSelectStyles;
+var _shims$1 = shims;
+var _getPrefix = _interopRequireWildcard(getPrefix$1);
+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 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$2(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 _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 matchesSelectorFunc = "";
+function matchesSelector(el, selector) {
+  if (!matchesSelectorFunc) {
+    matchesSelectorFunc = (0, _shims$1.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(method) {
+      return (0, _shims$1.isFunction)(el[method]);
+    });
+  }
+  if (!(0, _shims$1.isFunction)(el[matchesSelectorFunc]))
+    return false;
+  return el[matchesSelectorFunc](selector);
+}
+function matchesSelectorAndParentsTo(el, selector, baseNode) {
+  var node = el;
+  do {
+    if (matchesSelector(node, selector))
+      return true;
+    if (node === baseNode)
+      return false;
+    node = node.parentNode;
+  } while (node);
+  return false;
+}
+function addEvent(el, event, handler, inputOptions) {
+  if (!el)
+    return;
+  var options = _objectSpread$2({
+    capture: true
+  }, inputOptions);
+  if (el.addEventListener) {
+    el.addEventListener(event, handler, options);
+  } else if (el.attachEvent) {
+    el.attachEvent("on" + event, handler);
+  } else {
+    el["on" + event] = handler;
+  }
+}
+function removeEvent(el, event, handler, inputOptions) {
+  if (!el)
+    return;
+  var options = _objectSpread$2({
+    capture: true
+  }, inputOptions);
+  if (el.removeEventListener) {
+    el.removeEventListener(event, handler, options);
+  } else if (el.detachEvent) {
+    el.detachEvent("on" + event, handler);
+  } else {
+    el["on" + event] = null;
+  }
+}
+function outerHeight(node) {
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height += (0, _shims$1.int)(computedStyle.borderTopWidth);
+  height += (0, _shims$1.int)(computedStyle.borderBottomWidth);
+  return height;
+}
+function outerWidth(node) {
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width += (0, _shims$1.int)(computedStyle.borderLeftWidth);
+  width += (0, _shims$1.int)(computedStyle.borderRightWidth);
+  return width;
+}
+function innerHeight(node) {
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height -= (0, _shims$1.int)(computedStyle.paddingTop);
+  height -= (0, _shims$1.int)(computedStyle.paddingBottom);
+  return height;
+}
+function innerWidth(node) {
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width -= (0, _shims$1.int)(computedStyle.paddingLeft);
+  width -= (0, _shims$1.int)(computedStyle.paddingRight);
+  return width;
+}
+function offsetXYFromParent(evt, offsetParent, scale) {
+  var isBody = offsetParent === offsetParent.ownerDocument.body;
+  var offsetParentRect = isBody ? {
+    left: 0,
+    top: 0
+  } : offsetParent.getBoundingClientRect();
+  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+  return {
+    x,
+    y
+  };
+}
+function createCSSTransform(controlPos, positionOffset) {
+  var translation = getTranslation(controlPos, positionOffset, "px");
+  return _defineProperty$2({}, (0, _getPrefix.browserPrefixToKey)("transform", _getPrefix.default), translation);
+}
+function createSVGTransform(controlPos, positionOffset) {
+  var translation = getTranslation(controlPos, positionOffset, "");
+  return translation;
+}
+function getTranslation(_ref2, positionOffset, unitSuffix) {
+  var x = _ref2.x, y = _ref2.y;
+  var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+  if (positionOffset) {
+    var defaultX = "".concat(typeof positionOffset.x === "string" ? positionOffset.x : positionOffset.x + unitSuffix);
+    var defaultY = "".concat(typeof positionOffset.y === "string" ? positionOffset.y : positionOffset.y + unitSuffix);
+    translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
+  }
+  return translation;
+}
+function getTouch(e, identifier) {
+  return e.targetTouches && (0, _shims$1.findInArray)(e.targetTouches, function(t) {
+    return identifier === t.identifier;
+  }) || e.changedTouches && (0, _shims$1.findInArray)(e.changedTouches, function(t) {
+    return identifier === t.identifier;
+  });
+}
+function getTouchIdentifier(e) {
+  if (e.targetTouches && e.targetTouches[0])
+    return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0])
+    return e.changedTouches[0].identifier;
+}
+function addUserSelectStyles(doc) {
+  if (!doc)
+    return;
+  var styleEl = doc.getElementById("react-draggable-style-el");
+  if (!styleEl) {
+    styleEl = doc.createElement("style");
+    styleEl.type = "text/css";
+    styleEl.id = "react-draggable-style-el";
+    styleEl.innerHTML = ".react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n";
+    styleEl.innerHTML += ".react-draggable-transparent-selection *::selection {all: inherit;}\n";
+    doc.getElementsByTagName("head")[0].appendChild(styleEl);
+  }
+  if (doc.body)
+    addClassName(doc.body, "react-draggable-transparent-selection");
+}
+function removeUserSelectStyles(doc) {
+  if (!doc)
+    return;
+  try {
+    if (doc.body)
+      removeClassName(doc.body, "react-draggable-transparent-selection");
+    if (doc.selection) {
+      doc.selection.empty();
+    } else {
+      var selection = (doc.defaultView || window).getSelection();
+      if (selection && selection.type !== "Caret") {
+        selection.removeAllRanges();
+      }
+    }
+  } catch (e) {
+  }
+}
+function addClassName(el, className) {
+  if (el.classList) {
+    el.classList.add(className);
+  } else {
+    if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
+      el.className += " ".concat(className);
+    }
+  }
+}
+function removeClassName(el, className) {
+  if (el.classList) {
+    el.classList.remove(className);
+  } else {
+    el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), "g"), "");
+  }
+}
+var positionFns = {};
+Object.defineProperty(positionFns, "__esModule", {
+  value: true
+});
+positionFns.canDragX = canDragX;
+positionFns.canDragY = canDragY;
+positionFns.createCoreData = createCoreData;
+positionFns.createDraggableData = createDraggableData;
+positionFns.getBoundPosition = getBoundPosition;
+positionFns.getControlPosition = getControlPosition;
+positionFns.snapToGrid = snapToGrid;
+var _shims = shims;
+var _domFns = domFns;
+function getBoundPosition(draggable, x, y) {
+  if (!draggable.props.bounds)
+    return [x, y];
+  var bounds = draggable.props.bounds;
+  bounds = typeof bounds === "string" ? bounds : cloneBounds(bounds);
+  var node = findDOMNode(draggable);
+  if (typeof bounds === "string") {
+    var ownerDocument = node.ownerDocument;
+    var ownerWindow = ownerDocument.defaultView;
+    var boundNode;
+    if (bounds === "parent") {
+      boundNode = node.parentNode;
+    } else {
+      boundNode = ownerDocument.querySelector(bounds);
+    }
+    if (!(boundNode instanceof ownerWindow.HTMLElement)) {
+      throw new Error('Bounds selector "' + bounds + '" could not find an element.');
+    }
+    var boundNodeEl = boundNode;
+    var nodeStyle = ownerWindow.getComputedStyle(node);
+    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);
+    bounds = {
+      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
+      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
+      right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
+      bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
+    };
+  }
+  if ((0, _shims.isNum)(bounds.right))
+    x = Math.min(x, bounds.right);
+  if ((0, _shims.isNum)(bounds.bottom))
+    y = Math.min(y, bounds.bottom);
+  if ((0, _shims.isNum)(bounds.left))
+    x = Math.max(x, bounds.left);
+  if ((0, _shims.isNum)(bounds.top))
+    y = Math.max(y, bounds.top);
+  return [x, y];
+}
+function snapToGrid(grid, pendingX, pendingY) {
+  var x = Math.round(pendingX / grid[0]) * grid[0];
+  var y = Math.round(pendingY / grid[1]) * grid[1];
+  return [x, y];
+}
+function canDragX(draggable) {
+  return draggable.props.axis === "both" || draggable.props.axis === "x";
+}
+function canDragY(draggable) {
+  return draggable.props.axis === "both" || draggable.props.axis === "y";
+}
+function getControlPosition(e, touchIdentifier, draggableCore) {
+  var touchObj = typeof touchIdentifier === "number" ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
+  if (typeof touchIdentifier === "number" && !touchObj)
+    return null;
+  var node = findDOMNode(draggableCore);
+  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
+}
+function createCoreData(draggable, x, y) {
+  var state = draggable.state;
+  var isStart = !(0, _shims.isNum)(state.lastX);
+  var node = findDOMNode(draggable);
+  if (isStart) {
+    return {
+      node,
+      deltaX: 0,
+      deltaY: 0,
+      lastX: x,
+      lastY: y,
+      x,
+      y
+    };
+  } else {
+    return {
+      node,
+      deltaX: x - state.lastX,
+      deltaY: y - state.lastY,
+      lastX: state.lastX,
+      lastY: state.lastY,
+      x,
+      y
+    };
+  }
+}
+function createDraggableData(draggable, coreData) {
+  var scale = draggable.props.scale;
+  return {
+    node: coreData.node,
+    x: draggable.state.x + coreData.deltaX / scale,
+    y: draggable.state.y + coreData.deltaY / scale,
+    deltaX: coreData.deltaX / scale,
+    deltaY: coreData.deltaY / scale,
+    lastX: draggable.state.x,
+    lastY: draggable.state.y
+  };
+}
+function cloneBounds(bounds) {
+  return {
+    left: bounds.left,
+    top: bounds.top,
+    right: bounds.right,
+    bottom: bounds.bottom
+  };
+}
+function findDOMNode(draggable) {
+  var node = draggable.findDOMNode();
+  if (!node) {
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  }
+  return node;
+}
+var log$2 = {};
+Object.defineProperty(log$2, "__esModule", {
+  value: true
+});
+log$2.default = log$1;
+function log$1() {
+}
+const getPaletteColor = function(palette, s) {
+  s = s.replace(/\[(\w+)\]/g, ".$1");
+  s = s.replace(/^\./, "");
+  let o = palette;
+  const a = s.split(".");
+  for (let i = 0, n = a.length; i < n; ++i) {
+    const k = a[i];
+    if (k in o) {
+      o = o[k];
+    } else {
+      return palette.action.active;
+    }
+  }
+  return o;
+};
+const getVariantColor = (variant) => {
+  switch (variant) {
+    case "warning":
+      return "warning";
+    case "delete":
+      return "error";
+    case "info":
+      return "info";
+  }
+  return "primary";
+};
+const getThemeVariantColor = (theme, variant) => {
+  switch (variant) {
+    case "warning":
+      theme.palette.warning.main;
+      break;
+    case "delete":
+      theme.palette.error.main;
+      break;
+    case "info":
+      theme.palette.info.main;
+      break;
+  }
+  return theme.palette.text.primary;
+};
+var utils$1 = {};
+utils$1.__esModule = true;
+utils$1.cloneElement = cloneElement;
+var _react$1 = _interopRequireDefault$1(React__default);
+function _interopRequireDefault$1(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (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 = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys$1(Object(source), true).forEach(function(key) {
+        _defineProperty$1(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys$1(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+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;
+}
+function cloneElement(element, props) {
+  if (props.style && element.props.style) {
+    props.style = _objectSpread$1(_objectSpread$1({}, element.props.style), props.style);
+  }
+  if (props.className && element.props.className) {
+    props.className = element.props.className + " " + props.className;
+  }
+  return /* @__PURE__ */ _react$1.default.cloneElement(element, props);
+}
+var utils = {};
+Object.defineProperty(utils, "__esModule", {
+  value: true
+});
+utils.bottom = bottom;
+utils.childrenEqual = childrenEqual;
+utils.cloneLayout = cloneLayout;
+utils.cloneLayoutItem = cloneLayoutItem;
+utils.collides = collides;
+utils.compact = compact;
+utils.compactItem = compactItem;
+utils.compactType = compactType;
+utils.correctBounds = correctBounds;
+utils.fastPositionEqual = fastPositionEqual;
+utils.fastRGLPropsEqual = void 0;
+utils.getAllCollisions = getAllCollisions;
+utils.getFirstCollision = getFirstCollision;
+utils.getLayoutItem = getLayoutItem;
+utils.getStatics = getStatics;
+utils.modifyLayout = modifyLayout;
+utils.moveElement = moveElement;
+utils.moveElementAwayFromCollision = moveElementAwayFromCollision;
+utils.noop = void 0;
+utils.perc = perc;
+utils.setTopLeft = setTopLeft;
+utils.setTransform = setTransform;
+utils.sortLayoutItems = sortLayoutItems;
+utils.sortLayoutItemsByColRow = sortLayoutItemsByColRow;
+utils.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;
+utils.synchronizeLayoutWithChildren = synchronizeLayoutWithChildren;
+utils.validateLayout = validateLayout;
+utils.withLayoutItem = withLayoutItem;
+var _lodash = _interopRequireDefault(require$$0);
+var _react = _interopRequireDefault(React__default);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+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(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 _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 isProduction = process.env.NODE_ENV === "production";
+function bottom(layout) {
+  var max = 0, bottomY;
+  for (var i = 0, len = layout.length; i < len; i++) {
+    bottomY = layout[i].y + layout[i].h;
+    if (bottomY > max)
+      max = bottomY;
+  }
+  return max;
+}
+function cloneLayout(layout) {
+  var newLayout = Array(layout.length);
+  for (var i = 0, len = layout.length; i < len; i++) {
+    newLayout[i] = cloneLayoutItem(layout[i]);
+  }
+  return newLayout;
+}
+function modifyLayout(layout, layoutItem) {
+  var newLayout = Array(layout.length);
+  for (var i = 0, len = layout.length; i < len; i++) {
+    if (layoutItem.i === layout[i].i) {
+      newLayout[i] = layoutItem;
+    } else {
+      newLayout[i] = layout[i];
+    }
+  }
+  return newLayout;
+}
+function withLayoutItem(layout, itemKey, cb) {
+  var item = getLayoutItem(layout, itemKey);
+  if (!item)
+    return [layout, null];
+  item = cb(cloneLayoutItem(item));
+  layout = modifyLayout(layout, item);
+  return [layout, item];
+}
+function cloneLayoutItem(layoutItem) {
+  return {
+    w: layoutItem.w,
+    h: layoutItem.h,
+    x: layoutItem.x,
+    y: layoutItem.y,
+    i: layoutItem.i,
+    minW: layoutItem.minW,
+    maxW: layoutItem.maxW,
+    minH: layoutItem.minH,
+    maxH: layoutItem.maxH,
+    moved: Boolean(layoutItem.moved),
+    static: Boolean(layoutItem.static),
+    isDraggable: layoutItem.isDraggable,
+    isResizable: layoutItem.isResizable,
+    resizeHandles: layoutItem.resizeHandles,
+    isBounded: layoutItem.isBounded
+  };
+}
+function childrenEqual(a, b) {
+  return (0, _lodash.default)(_react.default.Children.map(a, function(c) {
+    return c === null || c === void 0 ? void 0 : c.key;
+  }), _react.default.Children.map(b, function(c) {
+    return c === null || c === void 0 ? void 0 : c.key;
+  }));
+}
+var fastRGLPropsEqual = fastRGLPropsEqual$1;
+utils.fastRGLPropsEqual = fastRGLPropsEqual;
+function fastPositionEqual(a, b) {
+  return a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height;
+}
+function collides(l1, l2) {
+  if (l1.i === l2.i)
+    return false;
+  if (l1.x + l1.w <= l2.x)
+    return false;
+  if (l1.x >= l2.x + l2.w)
+    return false;
+  if (l1.y + l1.h <= l2.y)
+    return false;
+  if (l1.y >= l2.y + l2.h)
+    return false;
+  return true;
+}
+function compact(layout, compactType2, cols) {
+  var compareWith = getStatics(layout);
+  var sorted = sortLayoutItems(layout, compactType2);
+  var out = Array(layout.length);
+  for (var i = 0, len = sorted.length; i < len; i++) {
+    var l = cloneLayoutItem(sorted[i]);
+    if (!l.static) {
+      l = compactItem(compareWith, l, compactType2, cols, sorted);
+      compareWith.push(l);
+    }
+    out[layout.indexOf(sorted[i])] = l;
+    l.moved = false;
+  }
+  return out;
+}
+var heightWidth = {
+  x: "w",
+  y: "h"
+};
+function resolveCompactionCollision(layout, item, moveToCoord, axis) {
+  var sizeProp = heightWidth[axis];
+  item[axis] += 1;
+  var itemIndex = layout.map(function(layoutItem) {
+    return layoutItem.i;
+  }).indexOf(item.i);
+  for (var i = itemIndex + 1; i < layout.length; i++) {
+    var otherItem = layout[i];
+    if (otherItem.static)
+      continue;
+    if (otherItem.y > item.y + item.h)
+      break;
+    if (collides(item, otherItem)) {
+      resolveCompactionCollision(layout, otherItem, moveToCoord + item[sizeProp], axis);
+    }
+  }
+  item[axis] = moveToCoord;
+}
+function compactItem(compareWith, l, compactType2, cols, fullLayout) {
+  var compactV = compactType2 === "vertical";
+  var compactH = compactType2 === "horizontal";
+  if (compactV) {
+    l.y = Math.min(bottom(compareWith), l.y);
+    while (l.y > 0 && !getFirstCollision(compareWith, l)) {
+      l.y--;
+    }
+  } else if (compactH) {
+    while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+      l.x--;
+    }
+  }
+  var collides2;
+  while (collides2 = getFirstCollision(compareWith, l)) {
+    if (compactH) {
+      resolveCompactionCollision(fullLayout, l, collides2.x + collides2.w, "x");
+    } else {
+      resolveCompactionCollision(fullLayout, l, collides2.y + collides2.h, "y");
+    }
+    if (compactH && l.x + l.w > cols) {
+      l.x = cols - l.w;
+      l.y++;
+    }
+  }
+  l.y = Math.max(l.y, 0);
+  l.x = Math.max(l.x, 0);
+  return l;
+}
+function correctBounds(layout, bounds) {
+  var collidesWith = getStatics(layout);
+  for (var i = 0, len = layout.length; i < len; i++) {
+    var l = layout[i];
+    if (l.x + l.w > bounds.cols)
+      l.x = bounds.cols - l.w;
+    if (l.x < 0) {
+      l.x = 0;
+      l.w = bounds.cols;
+    }
+    if (!l.static)
+      collidesWith.push(l);
+    else {
+      while (getFirstCollision(collidesWith, l)) {
+        l.y++;
+      }
+    }
+  }
+  return layout;
+}
+function getLayoutItem(layout, id) {
+  for (var i = 0, len = layout.length; i < len; i++) {
+    if (layout[i].i === id)
+      return layout[i];
+  }
+}
+function getFirstCollision(layout, layoutItem) {
+  for (var i = 0, len = layout.length; i < len; i++) {
+    if (collides(layout[i], layoutItem))
+      return layout[i];
+  }
+}
+function getAllCollisions(layout, layoutItem) {
+  return layout.filter(function(l) {
+    return collides(l, layoutItem);
+  });
+}
+function getStatics(layout) {
+  return layout.filter(function(l) {
+    return l.static;
+  });
+}
+function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType2, cols, allowOverlap) {
+  if (l.static && l.isDraggable !== true)
+    return layout;
+  if (l.y === y && l.x === x)
+    return layout;
+  log("Moving element ".concat(l.i, " to [").concat(String(x), ",").concat(String(y), "] from [").concat(l.x, ",").concat(l.y, "]"));
+  var oldX = l.x;
+  var oldY = l.y;
+  if (typeof x === "number")
+    l.x = x;
+  if (typeof y === "number")
+    l.y = y;
+  l.moved = true;
+  var sorted = sortLayoutItems(layout, compactType2);
+  var movingUp = compactType2 === "vertical" && typeof y === "number" ? oldY >= y : compactType2 === "horizontal" && typeof x === "number" ? oldX >= x : false;
+  if (movingUp)
+    sorted = sorted.reverse();
+  var collisions = getAllCollisions(sorted, l);
+  var hasCollisions = collisions.length > 0;
+  if (hasCollisions && allowOverlap) {
+    return cloneLayout(layout);
+  } else if (hasCollisions && preventCollision) {
+    log("Collision prevented on ".concat(l.i, ", reverting."));
+    l.x = oldX;
+    l.y = oldY;
+    l.moved = false;
+    return layout;
+  }
+  for (var i = 0, len = collisions.length; i < len; i++) {
+    var collision = collisions[i];
+    log("Resolving collision between ".concat(l.i, " at [").concat(l.x, ",").concat(l.y, "] and ").concat(collision.i, " at [").concat(collision.x, ",").concat(collision.y, "]"));
+    if (collision.moved)
+      continue;
+    if (collision.static) {
+      layout = moveElementAwayFromCollision(layout, collision, l, isUserAction, compactType2);
+    } else {
+      layout = moveElementAwayFromCollision(layout, l, collision, isUserAction, compactType2);
+    }
+  }
+  return layout;
+}
+function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType2, cols) {
+  var compactH = compactType2 === "horizontal";
+  var compactV = compactType2 !== "horizontal";
+  var preventCollision = collidesWith.static;
+  if (isUserAction) {
+    isUserAction = false;
+    var fakeItem = {
+      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,
+      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,
+      w: itemToMove.w,
+      h: itemToMove.h,
+      i: "-1"
+    };
+    if (!getFirstCollision(layout, fakeItem)) {
+      log("Doing reverse collision on ".concat(itemToMove.i, " up to [").concat(fakeItem.x, ",").concat(fakeItem.y, "]."));
+      return moveElement(layout, itemToMove, compactH ? fakeItem.x : void 0, compactV ? fakeItem.y : void 0, isUserAction, preventCollision, compactType2);
+    }
+  }
+  return moveElement(layout, itemToMove, compactH ? itemToMove.x + 1 : void 0, compactV ? itemToMove.y + 1 : void 0, isUserAction, preventCollision, compactType2);
+}
+function perc(num) {
+  return num * 100 + "%";
+}
+function setTransform(_ref) {
+  var top = _ref.top, left = _ref.left, width = _ref.width, height = _ref.height;
+  var translate = "translate(".concat(left, "px,").concat(top, "px)");
+  return {
+    transform: translate,
+    WebkitTransform: translate,
+    MozTransform: translate,
+    msTransform: translate,
+    OTransform: translate,
+    width: "".concat(width, "px"),
+    height: "".concat(height, "px"),
+    position: "absolute"
+  };
+}
+function setTopLeft(_ref2) {
+  var top = _ref2.top, left = _ref2.left, width = _ref2.width, height = _ref2.height;
+  return {
+    top: "".concat(top, "px"),
+    left: "".concat(left, "px"),
+    width: "".concat(width, "px"),
+    height: "".concat(height, "px"),
+    position: "absolute"
+  };
+}
+function sortLayoutItems(layout, compactType2) {
+  if (compactType2 === "horizontal")
+    return sortLayoutItemsByColRow(layout);
+  if (compactType2 === "vertical")
+    return sortLayoutItemsByRowCol(layout);
+  else
+    return layout;
+}
+function sortLayoutItemsByRowCol(layout) {
+  return layout.slice(0).sort(function(a, b) {
+    if (a.y > b.y || a.y === b.y && a.x > b.x) {
+      return 1;
+    } else if (a.y === b.y && a.x === b.x) {
+      return 0;
+    }
+    return -1;
+  });
+}
+function sortLayoutItemsByColRow(layout) {
+  return layout.slice(0).sort(function(a, b) {
+    if (a.x > b.x || a.x === b.x && a.y > b.y) {
+      return 1;
+    }
+    return -1;
+  });
+}
+function synchronizeLayoutWithChildren(initialLayout, children, cols, compactType2, allowOverlap) {
+  initialLayout = initialLayout || [];
+  var layout = [];
+  _react.default.Children.forEach(children, function(child) {
+    if ((child === null || child === void 0 ? void 0 : child.key) == null)
+      return;
+    var exists = getLayoutItem(initialLayout, String(child.key));
+    if (exists) {
+      layout.push(cloneLayoutItem(exists));
+    } else {
+      if (!isProduction && child.props._grid) {
+        console.warn("`_grid` properties on children have been deprecated as of React 15.2. Please use `data-grid` or add your properties directly to the `layout`.");
+      }
+      var g = child.props["data-grid"] || child.props._grid;
+      if (g) {
+        if (!isProduction) {
+          validateLayout([g], "ReactGridLayout.children");
+        }
+        layout.push(cloneLayoutItem(_objectSpread(_objectSpread({}, g), {}, {
+          i: child.key
+        })));
+      } else {
+        layout.push(cloneLayoutItem({
+          w: 1,
+          h: 1,
+          x: 0,
+          y: bottom(layout),
+          i: String(child.key)
+        }));
+      }
+    }
+  });
+  var correctedLayout = correctBounds(layout, {
+    cols
+  });
+  return allowOverlap ? correctedLayout : compact(correctedLayout, compactType2, cols);
+}
+function validateLayout(layout) {
+  var contextName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Layout";
+  var subProps = ["x", "y", "w", "h"];
+  if (!Array.isArray(layout))
+    throw new Error(contextName + " must be an array!");
+  for (var i = 0, len = layout.length; i < len; i++) {
+    var item = layout[i];
+    for (var j = 0; j < subProps.length; j++) {
+      if (typeof item[subProps[j]] !== "number") {
+        throw new Error("ReactGridLayout: " + contextName + "[" + i + "]." + subProps[j] + " must be a number!");
+      }
+    }
+  }
+}
+function compactType(props) {
+  var _ref3 = props || {}, verticalCompact = _ref3.verticalCompact, compactType2 = _ref3.compactType;
+  return verticalCompact === false ? null : compactType2;
+}
+function log() {
+  return;
+}
+var noop = function noop2() {
+};
+utils.noop = noop;
+export {
+  getThemeVariantColor as a,
+  utils$1 as b,
+  getVariantColor as c,
+  domFns as d,
+  getPaletteColor as g,
+  log$2 as l,
+  positionFns as p,
+  shims as s,
+  utils as u
+};