react-grid-layout.min.js.map

{"version":3,"file":"react-grid-layout.min.js","mappings":"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","sources":["webpack://ReactGridLayout/webpack/universalModuleDefinition","webpack://ReactGridLayout/./index-dev.js","webpack://ReactGridLayout/./lib/calculateUtils.js","webpack://ReactGridLayout/./lib/ReactGridLayoutPropTypes.js","webpack://ReactGridLayout/./lib/GridItem.jsx","webpack://ReactGridLayout/./lib/ReactGridLayout.jsx","webpack://ReactGridLayout/./lib/ResponsiveReactGridLayout.jsx","webpack://ReactGridLayout/./lib/components/WidthProvider.jsx","webpack://ReactGridLayout/./lib/responsiveUtils.js","webpack://ReactGridLayout/./lib/utils.js","webpack://ReactGridLayout/./node_modules/clsx/dist/clsx.m.js","webpack://ReactGridLayout/./node_modules/lodash.isequal/index.js","webpack://ReactGridLayout/./node_modules/prop-types/factoryWithThrowingShims.js","webpack://ReactGridLayout/./node_modules/prop-types/index.js","webpack://ReactGridLayout/./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/Draggable.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/DraggableCore.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/cjs.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/utils/domFns.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/utils/getPrefix.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/utils/log.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/utils/positionFns.js","webpack://ReactGridLayout/./node_modules/react-draggable/build/cjs/utils/shims.js","webpack://ReactGridLayout/./node_modules/react-resizable/build/Resizable.js","webpack://ReactGridLayout/./node_modules/react-resizable/build/ResizableBox.js","webpack://ReactGridLayout/./node_modules/react-resizable/build/propTypes.js","webpack://ReactGridLayout/./node_modules/react-resizable/build/utils.js","webpack://ReactGridLayout/./node_modules/react-resizable/index.js","webpack://ReactGridLayout/external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}","webpack://ReactGridLayout/external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}","webpack://ReactGridLayout/webpack/bootstrap","webpack://ReactGridLayout/webpack/runtime/compat get default export","webpack://ReactGridLayout/webpack/runtime/define property getters","webpack://ReactGridLayout/webpack/runtime/global","webpack://ReactGridLayout/webpack/runtime/hasOwnProperty shorthand","webpack://ReactGridLayout/webpack/runtime/make namespace object","webpack://ReactGridLayout/webpack/runtime/node module decorator","webpack://ReactGridLayout/webpack/startup"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"), require(\"react-dom\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\", \"react-dom\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactGridLayout\"] = factory(require(\"react\"), require(\"react-dom\"));\n\telse\n\t\troot[\"ReactGridLayout\"] = factory(root[\"React\"], root[\"ReactDOM\"]);\n})(self, function(__WEBPACK_EXTERNAL_MODULE__888__, __WEBPACK_EXTERNAL_MODULE__757__) {\nreturn ","module.exports = require(\"./lib/ReactGridLayout\").default;\nmodule.exports.utils = require(\"./lib/utils\");\nmodule.exports.Responsive = require(\"./lib/ResponsiveReactGridLayout\").default;\nmodule.exports.Responsive.utils = require(\"./lib/responsiveUtils\");\nmodule.exports.WidthProvider = require(\"./lib/components/WidthProvider\").default;\n","// @flow\nimport type { Position } from \"./utils\";\n\nexport type PositionParams = {\n  margin: [number, number],\n  containerPadding: [number, number],\n  containerWidth: number,\n  cols: number,\n  rowHeight: number,\n  maxRows: number\n};\n\n// Helper for generating column width\nexport function calcGridColWidth(positionParams: PositionParams): number {\n  const { margin, containerPadding, containerWidth, cols } = positionParams;\n  return (\n    (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols\n  );\n}\n\n// This can either be called:\n// calcGridItemWHPx(w, colWidth, margin[0])\n// or\n// calcGridItemWHPx(h, rowHeight, margin[1])\nexport function calcGridItemWHPx(\n  gridUnits: number,\n  colOrRowSize: number,\n  marginPx: number\n): number {\n  // 0 * Infinity === NaN, which causes problems with resize contraints\n  if (!Number.isFinite(gridUnits)) return gridUnits;\n  return Math.round(\n    colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx\n  );\n}\n\n/**\n * Return position on the page given an x, y, w, h.\n * left, top, width, height are all in pixels.\n * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calculations.\n * @param  {Number}  x                      X coordinate in grid units.\n * @param  {Number}  y                      Y coordinate in grid units.\n * @param  {Number}  w                      W coordinate in grid units.\n * @param  {Number}  h                      H coordinate in grid units.\n * @return {Position}                       Object containing coords.\n */\nexport function calcGridItemPosition(\n  positionParams: PositionParams,\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n  state: ?Object\n): Position {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n  const out = {};\n\n  // If resizing, use the exact width and height as returned from resizing callbacks.\n  if (state && state.resizing) {\n    out.width = Math.round(state.resizing.width);\n    out.height = Math.round(state.resizing.height);\n  }\n  // Otherwise, calculate from grid units.\n  else {\n    out.width = calcGridItemWHPx(w, colWidth, margin[0]);\n    out.height = calcGridItemWHPx(h, rowHeight, margin[1]);\n  }\n\n  // If dragging, use the exact width and height as returned from dragging callbacks.\n  if (state && state.dragging) {\n    out.top = Math.round(state.dragging.top);\n    out.left = Math.round(state.dragging.left);\n  }\n  // Otherwise, calculate from grid units.\n  else {\n    out.top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);\n    out.left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);\n  }\n\n  return out;\n}\n\n/**\n * Translate x and y coordinates from pixels to grid units.\n * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calculations.\n * @param  {Number} top                     Top position (relative to parent) in pixels.\n * @param  {Number} left                    Left position (relative to parent) in pixels.\n * @param  {Number} w                       W coordinate in grid units.\n * @param  {Number} h                       H coordinate in grid units.\n * @return {Object}                         x and y in grid units.\n */\nexport function calcXY(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n  w: number,\n  h: number\n): { x: number, y: number } {\n  const { margin, cols, rowHeight, maxRows } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  // left = colWidth * x + margin * (x + 1)\n  // l = cx + m(x+1)\n  // l = cx + mx + m\n  // l - m = cx + mx\n  // l - m = x(c + m)\n  // (l - m) / (c + m) = x\n  // x = (left - margin) / (coldWidth + margin)\n  let x = Math.round((left - margin[0]) / (colWidth + margin[0]));\n  let y = Math.round((top - margin[1]) / (rowHeight + margin[1]));\n\n  // Capping\n  x = clamp(x, 0, cols - w);\n  y = clamp(y, 0, maxRows - h);\n  return { x, y };\n}\n\n/**\n * Given a height and width in pixel values, calculate grid units.\n * @param  {PositionParams} positionParams  Parameters of grid needed for coordinates calcluations.\n * @param  {Number} height                  Height in pixels.\n * @param  {Number} width                   Width in pixels.\n * @param  {Number} x                       X coordinate in grid units.\n * @param  {Number} y                       Y coordinate in grid units.\n * @return {Object}                         w, h as grid units.\n */\nexport function calcWH(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n  x: number,\n  y: number\n): { w: number, h: number } {\n  const { margin, maxRows, cols, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  // width = colWidth * w - (margin * (w - 1))\n  // ...\n  // w = (width + margin) / (colWidth + margin)\n  let w = Math.round((width + margin[0]) / (colWidth + margin[0]));\n  let h = Math.round((height + margin[1]) / (rowHeight + margin[1]));\n\n  // Capping\n  w = clamp(w, 0, cols - x);\n  h = clamp(h, 0, maxRows - y);\n  return { w, h };\n}\n\n// Similar to _.clamp\nexport function clamp(\n  num: number,\n  lowerBound: number,\n  upperBound: number\n): number {\n  return Math.max(Math.min(num, upperBound), lowerBound);\n}\n","// @flow\nimport PropTypes from \"prop-types\";\nimport React from \"react\";\nimport type {\n  Ref,\n  ChildrenArray as ReactChildrenArray,\n  Element as ReactElement\n} from \"react\";\nimport type {\n  DragOverEvent,\n  EventCallback,\n  CompactType,\n  Layout,\n  LayoutItem\n} from \"./utils\";\n\n// util\nexport type ReactRef<T: HTMLElement> = {|\n  +current: T | null\n|};\n\nexport type ResizeHandleAxis =\n  | \"s\"\n  | \"w\"\n  | \"e\"\n  | \"n\"\n  | \"sw\"\n  | \"nw\"\n  | \"se\"\n  | \"ne\";\nexport type ResizeHandle =\n  | ReactElement<any>\n  | ((\n      resizeHandleAxis: ResizeHandleAxis,\n      ref: ReactRef<HTMLElement>\n    ) => ReactElement<any>);\n\n// Defines which resize handles should be rendered (default: 'se')\n// Allows for any combination of:\n// 's' - South handle (bottom-center)\n// 'w' - West handle (left-center)\n// 'e' - East handle (right-center)\n// 'n' - North handle (top-center)\n// 'sw' - Southwest handle (bottom-left)\n// 'nw' - Northwest handle (top-left)\n// 'se' - Southeast handle (bottom-right)\n// 'ne' - Northeast handle (top-right)\nexport const resizeHandleAxesType: ReactPropsChainableTypeChecker =\n  PropTypes.arrayOf(\n    PropTypes.oneOf([\"s\", \"w\", \"e\", \"n\", \"sw\", \"nw\", \"se\", \"ne\"])\n  );\n// Custom component for resize handles\nexport const resizeHandleType: ReactPropsChainableTypeChecker =\n  PropTypes.oneOfType([PropTypes.node, PropTypes.func]);\n\nexport type Props = {|\n  className: string,\n  style: Object,\n  width: number,\n  autoSize: boolean,\n  cols: number,\n  draggableCancel: string,\n  draggableHandle: string,\n  verticalCompact: boolean,\n  compactType: CompactType,\n  layout: Layout,\n  margin: [number, number],\n  containerPadding: ?[number, number],\n  rowHeight: number,\n  maxRows: number,\n  isBounded: boolean,\n  isDraggable: boolean,\n  isResizable: boolean,\n  isDroppable: boolean,\n  preventCollision: boolean,\n  useCSSTransforms: boolean,\n  transformScale: number,\n  droppingItem: $Shape<LayoutItem>,\n  resizeHandles: ResizeHandleAxis[],\n  resizeHandle?: ResizeHandle,\n  allowOverlap: boolean,\n\n  // Callbacks\n  onLayoutChange: Layout => void,\n  onDrag: EventCallback,\n  onDragStart: EventCallback,\n  onDragStop: EventCallback,\n  onResize: EventCallback,\n  onResizeStart: EventCallback,\n  onResizeStop: EventCallback,\n  onDropDragOver: (e: DragOverEvent) => ?({| w?: number, h?: number |} | false),\n  onDrop: (layout: Layout, item: ?LayoutItem, e: Event) => void,\n  children: ReactChildrenArray<ReactElement<any>>,\n  innerRef?: Ref<\"div\">\n|};\n\nexport type DefaultProps = $Diff<\n  Props,\n  {\n    children: ReactChildrenArray<ReactElement<any>>,\n    width: number\n  }\n>;\n\nexport default {\n  //\n  // Basic props\n  //\n  className: PropTypes.string,\n  style: PropTypes.object,\n\n  // This can be set explicitly. If it is not set, it will automatically\n  // be set to the container width. Note that resizes will *not* cause this to adjust.\n  // If you need that behavior, use WidthProvider.\n  width: PropTypes.number,\n\n  // If true, the container height swells and contracts to fit contents\n  autoSize: PropTypes.bool,\n  // # of cols.\n  cols: PropTypes.number,\n\n  // A selector that will not be draggable.\n  draggableCancel: PropTypes.string,\n  // A selector for the draggable handler\n  draggableHandle: PropTypes.string,\n\n  // Deprecated\n  verticalCompact: function (props: Props) {\n    if (\n      props.verticalCompact === false &&\n      process.env.NODE_ENV !== \"production\"\n    ) {\n      console.warn(\n        // eslint-disable-line no-console\n        \"`verticalCompact` on <ReactGridLayout> is deprecated and will be removed soon. \" +\n          'Use `compactType`: \"horizontal\" | \"vertical\" | null.'\n      );\n    }\n  },\n  // Choose vertical or hotizontal compaction\n  compactType: (PropTypes.oneOf([\n    \"vertical\",\n    \"horizontal\"\n  ]): ReactPropsChainableTypeChecker),\n\n  // layout is an array of object with the format:\n  // {x: Number, y: Number, w: Number, h: Number, i: String}\n  layout: function (props: Props) {\n    var layout = props.layout;\n    // I hope you're setting the data-grid property on the grid items\n    if (layout === undefined) return;\n    require(\"./utils\").validateLayout(layout, \"layout\");\n  },\n\n  //\n  // Grid Dimensions\n  //\n\n  // Margin between items [x, y] in px\n  margin: (PropTypes.arrayOf(PropTypes.number): ReactPropsChainableTypeChecker),\n  // Padding inside the container [x, y] in px\n  containerPadding: (PropTypes.arrayOf(\n    PropTypes.number\n  ): ReactPropsChainableTypeChecker),\n  // Rows have a static height, but you can change this based on breakpoints if you like\n  rowHeight: PropTypes.number,\n  // Default Infinity, but you can specify a max here if you like.\n  // Note that this isn't fully fleshed out and won't error if you specify a layout that\n  // extends beyond the row capacity. It will, however, not allow users to drag/resize\n  // an item past the barrier. They can push items beyond the barrier, though.\n  // Intentionally not documented for this reason.\n  maxRows: PropTypes.number,\n\n  //\n  // Flags\n  //\n  isBounded: PropTypes.bool,\n  isDraggable: PropTypes.bool,\n  isResizable: PropTypes.bool,\n  // If true, grid can be placed one over the other.\n  allowOverlap: PropTypes.bool,\n  // If true, grid items won't change position when being dragged over.\n  preventCollision: PropTypes.bool,\n  // Use CSS transforms instead of top/left\n  useCSSTransforms: PropTypes.bool,\n  // parent layout transform scale\n  transformScale: PropTypes.number,\n  // If true, an external element can trigger onDrop callback with a specific grid position as a parameter\n  isDroppable: PropTypes.bool,\n\n  // Resize handle options\n  resizeHandles: resizeHandleAxesType,\n  resizeHandle: resizeHandleType,\n\n  //\n  // Callbacks\n  //\n\n  // Callback so you can save the layout. Calls after each drag & resize stops.\n  onLayoutChange: PropTypes.func,\n\n  // Calls when drag starts. Callback is of the signature (layout, oldItem, newItem, placeholder, e, ?node).\n  // All callbacks below have the same signature. 'start' and 'stop' callbacks omit the 'placeholder'.\n  onDragStart: PropTypes.func,\n  // Calls on each drag movement.\n  onDrag: PropTypes.func,\n  // Calls when drag is complete.\n  onDragStop: PropTypes.func,\n  //Calls when resize starts.\n  onResizeStart: PropTypes.func,\n  // Calls when resize movement happens.\n  onResize: PropTypes.func,\n  // Calls when resize is complete.\n  onResizeStop: PropTypes.func,\n  // Calls when some element is dropped.\n  onDrop: PropTypes.func,\n\n  //\n  // Other validations\n  //\n\n  droppingItem: (PropTypes.shape({\n    i: PropTypes.string.isRequired,\n    w: PropTypes.number.isRequired,\n    h: PropTypes.number.isRequired\n  }): ReactPropsChainableTypeChecker),\n\n  // Children must not have duplicate keys.\n  children: function (props: Props, propName: string) {\n    const children = props[propName];\n\n    // Check children keys for duplicates. Throw if found.\n    const keys = {};\n    React.Children.forEach(children, function (child) {\n      if (child?.key == null) return;\n      if (keys[child.key]) {\n        throw new Error(\n          'Duplicate child key \"' +\n            child.key +\n            '\" found! This will cause problems in ReactGridLayout.'\n        );\n      }\n      keys[child.key] = true;\n    });\n  },\n\n  // Optional ref for getting a reference for the wrapping div.\n  innerRef: PropTypes.any\n};\n","// @flow\nimport React from \"react\";\nimport PropTypes from \"prop-types\";\nimport { DraggableCore } from \"react-draggable\";\nimport { Resizable } from \"react-resizable\";\nimport { fastPositionEqual, perc, setTopLeft, setTransform } from \"./utils\";\nimport {\n  calcGridItemPosition,\n  calcGridItemWHPx,\n  calcGridColWidth,\n  calcXY,\n  calcWH,\n  clamp\n} from \"./calculateUtils\";\nimport {\n  resizeHandleAxesType,\n  resizeHandleType\n} from \"./ReactGridLayoutPropTypes\";\nimport clsx from \"clsx\";\nimport type { Element as ReactElement, Node as ReactNode } from \"react\";\n\nimport type {\n  ReactDraggableCallbackData,\n  GridDragEvent,\n  GridResizeEvent,\n  DroppingPosition,\n  Position\n} from \"./utils\";\n\nimport type { PositionParams } from \"./calculateUtils\";\nimport type {\n  ResizeHandleAxis,\n  ResizeHandle,\n  ReactRef\n} from \"./ReactGridLayoutPropTypes\";\n\ntype PartialPosition = { top: number, left: number };\ntype GridItemCallback<Data: GridDragEvent | GridResizeEvent> = (\n  i: string,\n  w: number,\n  h: number,\n  Data\n) => void;\n\ntype State = {\n  resizing: ?{ width: number, height: number },\n  dragging: ?{ top: number, left: number },\n  className: string\n};\n\ntype Props = {\n  children: ReactElement<any>,\n  cols: number,\n  containerWidth: number,\n  margin: [number, number],\n  containerPadding: [number, number],\n  rowHeight: number,\n  maxRows: number,\n  isDraggable: boolean,\n  isResizable: boolean,\n  isBounded: boolean,\n  static?: boolean,\n  useCSSTransforms?: boolean,\n  usePercentages?: boolean,\n  transformScale: number,\n  droppingPosition?: DroppingPosition,\n\n  className: string,\n  style?: Object,\n  // Draggability\n  cancel: string,\n  handle: string,\n\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n\n  minW: number,\n  maxW: number,\n  minH: number,\n  maxH: number,\n  i: string,\n\n  resizeHandles?: ResizeHandleAxis[],\n  resizeHandle?: ResizeHandle,\n\n  onDrag?: GridItemCallback<GridDragEvent>,\n  onDragStart?: GridItemCallback<GridDragEvent>,\n  onDragStop?: GridItemCallback<GridDragEvent>,\n  onResize?: GridItemCallback<GridResizeEvent>,\n  onResizeStart?: GridItemCallback<GridResizeEvent>,\n  onResizeStop?: GridItemCallback<GridResizeEvent>\n};\n\ntype DefaultProps = {\n  className: string,\n  cancel: string,\n  handle: string,\n  minH: number,\n  minW: number,\n  maxH: number,\n  maxW: number,\n  transformScale: number\n};\n\n/**\n * An individual item within a ReactGridLayout.\n */\nexport default class GridItem extends React.Component<Props, State> {\n  static propTypes = {\n    // Children must be only a single element\n    children: PropTypes.element,\n\n    // General grid attributes\n    cols: PropTypes.number.isRequired,\n    containerWidth: PropTypes.number.isRequired,\n    rowHeight: PropTypes.number.isRequired,\n    margin: PropTypes.array.isRequired,\n    maxRows: PropTypes.number.isRequired,\n    containerPadding: PropTypes.array.isRequired,\n\n    // These are all in grid units\n    x: PropTypes.number.isRequired,\n    y: PropTypes.number.isRequired,\n    w: PropTypes.number.isRequired,\n    h: PropTypes.number.isRequired,\n\n    // All optional\n    minW: function (props: Props, propName: string) {\n      const value = props[propName];\n      if (typeof value !== \"number\") return new Error(\"minWidth not Number\");\n      if (value > props.w || value > props.maxW)\n        return new Error(\"minWidth larger than item width/maxWidth\");\n    },\n\n    maxW: function (props: Props, propName: string) {\n      const value = props[propName];\n      if (typeof value !== \"number\") return new Error(\"maxWidth not Number\");\n      if (value < props.w || value < props.minW)\n        return new Error(\"maxWidth smaller than item width/minWidth\");\n    },\n\n    minH: function (props: Props, propName: string) {\n      const value = props[propName];\n      if (typeof value !== \"number\") return new Error(\"minHeight not Number\");\n      if (value > props.h || value > props.maxH)\n        return new Error(\"minHeight larger than item height/maxHeight\");\n    },\n\n    maxH: function (props: Props, propName: string) {\n      const value = props[propName];\n      if (typeof value !== \"number\") return new Error(\"maxHeight not Number\");\n      if (value < props.h || value < props.minH)\n        return new Error(\"maxHeight smaller than item height/minHeight\");\n    },\n\n    // ID is nice to have for callbacks\n    i: PropTypes.string.isRequired,\n\n    // Resize handle options\n    resizeHandles: resizeHandleAxesType,\n    resizeHandle: resizeHandleType,\n\n    // Functions\n    onDragStop: PropTypes.func,\n    onDragStart: PropTypes.func,\n    onDrag: PropTypes.func,\n    onResizeStop: PropTypes.func,\n    onResizeStart: PropTypes.func,\n    onResize: PropTypes.func,\n\n    // Flags\n    isDraggable: PropTypes.bool.isRequired,\n    isResizable: PropTypes.bool.isRequired,\n    isBounded: PropTypes.bool.isRequired,\n    static: PropTypes.bool,\n\n    // Use CSS transforms instead of top/left\n    useCSSTransforms: PropTypes.bool.isRequired,\n    transformScale: PropTypes.number,\n\n    // Others\n    className: PropTypes.string,\n    // Selector for draggable handle\n    handle: PropTypes.string,\n    // Selector for draggable cancel (see react-draggable)\n    cancel: PropTypes.string,\n    // Current position of a dropping element\n    droppingPosition: PropTypes.shape({\n      e: PropTypes.object.isRequired,\n      left: PropTypes.number.isRequired,\n      top: PropTypes.number.isRequired\n    })\n  };\n\n  static defaultProps: DefaultProps = {\n    className: \"\",\n    cancel: \"\",\n    handle: \"\",\n    minH: 1,\n    minW: 1,\n    maxH: Infinity,\n    maxW: Infinity,\n    transformScale: 1\n  };\n\n  state: State = {\n    resizing: null,\n    dragging: null,\n    className: \"\"\n  };\n\n  elementRef: ReactRef<HTMLDivElement> = React.createRef();\n\n  shouldComponentUpdate(nextProps: Props, nextState: State): boolean {\n    // We can't deeply compare children. If the developer memoizes them, we can\n    // use this optimization.\n    if (this.props.children !== nextProps.children) return true;\n    if (this.props.droppingPosition !== nextProps.droppingPosition) return true;\n    // TODO memoize these calculations so they don't take so long?\n    const oldPosition = calcGridItemPosition(\n      this.getPositionParams(this.props),\n      this.props.x,\n      this.props.y,\n      this.props.w,\n      this.props.h,\n      this.state\n    );\n    const newPosition = calcGridItemPosition(\n      this.getPositionParams(nextProps),\n      nextProps.x,\n      nextProps.y,\n      nextProps.w,\n      nextProps.h,\n      nextState\n    );\n    return (\n      !fastPositionEqual(oldPosition, newPosition) ||\n      this.props.useCSSTransforms !== nextProps.useCSSTransforms\n    );\n  }\n\n  componentDidMount() {\n    this.moveDroppingItem({});\n  }\n\n  componentDidUpdate(prevProps: Props) {\n    this.moveDroppingItem(prevProps);\n  }\n\n  // When a droppingPosition is present, this means we should fire a move event, as if we had moved\n  // this element by `x, y` pixels.\n  moveDroppingItem(prevProps: Props) {\n    const { droppingPosition } = this.props;\n    if (!droppingPosition) return;\n    const node = this.elementRef.current;\n    // Can't find DOM node (are we unmounted?)\n    if (!node) return;\n\n    const prevDroppingPosition = prevProps.droppingPosition || {\n      left: 0,\n      top: 0\n    };\n    const { dragging } = this.state;\n\n    const shouldDrag =\n      (dragging && droppingPosition.left !== prevDroppingPosition.left) ||\n      droppingPosition.top !== prevDroppingPosition.top;\n\n    if (!dragging) {\n      this.onDragStart(droppingPosition.e, {\n        node,\n        deltaX: droppingPosition.left,\n        deltaY: droppingPosition.top\n      });\n    } else if (shouldDrag) {\n      const deltaX = droppingPosition.left - dragging.left;\n      const deltaY = droppingPosition.top - dragging.top;\n\n      this.onDrag(droppingPosition.e, {\n        node,\n        deltaX,\n        deltaY\n      });\n    }\n  }\n\n  getPositionParams(props: Props = this.props): PositionParams {\n    return {\n      cols: props.cols,\n      containerPadding: props.containerPadding,\n      containerWidth: props.containerWidth,\n      margin: props.margin,\n      maxRows: props.maxRows,\n      rowHeight: props.rowHeight\n    };\n  }\n\n  /**\n   * This is where we set the grid item's absolute placement. It gets a little tricky because we want to do it\n   * well when server rendering, and the only way to do that properly is to use percentage width/left because\n   * we don't know exactly what the browser viewport is.\n   * Unfortunately, CSS Transforms, which are great for performance, break in this instance because a percentage\n   * left is relative to the item itself, not its container! So we cannot use them on the server rendering pass.\n   *\n   * @param  {Object} pos Position object with width, height, left, top.\n   * @return {Object}     Style object.\n   */\n  createStyle(pos: Position): { [key: string]: ?string } {\n    const { usePercentages, containerWidth, useCSSTransforms } = this.props;\n\n    let style;\n    // CSS Transforms support (default)\n    if (useCSSTransforms) {\n      style = setTransform(pos);\n    } else {\n      // top,left (slow)\n      style = setTopLeft(pos);\n\n      // This is used for server rendering.\n      if (usePercentages) {\n        style.left = perc(pos.left / containerWidth);\n        style.width = perc(pos.width / containerWidth);\n      }\n    }\n\n    return style;\n  }\n\n  /**\n   * Mix a Draggable instance into a child.\n   * @param  {Element} child    Child element.\n   * @return {Element}          Child wrapped in Draggable.\n   */\n  mixinDraggable(\n    child: ReactElement<any>,\n    isDraggable: boolean\n  ): ReactElement<any> {\n    return (\n      <DraggableCore\n        disabled={!isDraggable}\n        onStart={this.onDragStart}\n        onDrag={this.onDrag}\n        onStop={this.onDragStop}\n        handle={this.props.handle}\n        cancel={\n          \".react-resizable-handle\" +\n          (this.props.cancel ? \",\" + this.props.cancel : \"\")\n        }\n        scale={this.props.transformScale}\n        nodeRef={this.elementRef}\n      >\n        {child}\n      </DraggableCore>\n    );\n  }\n\n  /**\n   * Mix a Resizable instance into a child.\n   * @param  {Element} child    Child element.\n   * @param  {Object} position  Position object (pixel values)\n   * @return {Element}          Child wrapped in Resizable.\n   */\n  mixinResizable(\n    child: ReactElement<any>,\n    position: Position,\n    isResizable: boolean\n  ): ReactElement<any> {\n    const {\n      cols,\n      x,\n      minW,\n      minH,\n      maxW,\n      maxH,\n      transformScale,\n      resizeHandles,\n      resizeHandle\n    } = this.props;\n    const positionParams = this.getPositionParams();\n\n    // This is the max possible width - doesn't go to infinity because of the width of the window\n    const maxWidth = calcGridItemPosition(positionParams, 0, 0, cols - x, 0)\n      .width;\n\n    // Calculate min/max constraints using our min & maxes\n    const mins = calcGridItemPosition(positionParams, 0, 0, minW, minH);\n    const maxes = calcGridItemPosition(positionParams, 0, 0, maxW, maxH);\n    const minConstraints = [mins.width, mins.height];\n    const maxConstraints = [\n      Math.min(maxes.width, maxWidth),\n      Math.min(maxes.height, Infinity)\n    ];\n    return (\n      <Resizable\n        // These are opts for the resize handle itself\n        draggableOpts={{\n          disabled: !isResizable,\n        }}\n        className={isResizable ? undefined : \"react-resizable-hide\"}\n        width={position.width}\n        height={position.height}\n        minConstraints={minConstraints}\n        maxConstraints={maxConstraints}\n        onResizeStop={this.onResizeStop}\n        onResizeStart={this.onResizeStart}\n        onResize={this.onResize}\n        transformScale={transformScale}\n        resizeHandles={resizeHandles}\n        handle={resizeHandle}\n      >\n        {child}\n      </Resizable>\n    );\n  }\n\n  /**\n   * onDragStart event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node, delta and position information\n   */\n  onDragStart: (Event, ReactDraggableCallbackData) => void = (e, { node }) => {\n    const { onDragStart, transformScale } = this.props;\n    if (!onDragStart) return;\n\n    const newPosition: PartialPosition = { top: 0, left: 0 };\n\n    // TODO: this wont work on nested parents\n    const { offsetParent } = node;\n    if (!offsetParent) return;\n    const parentRect = offsetParent.getBoundingClientRect();\n    const clientRect = node.getBoundingClientRect();\n    const cLeft = clientRect.left / transformScale;\n    const pLeft = parentRect.left / transformScale;\n    const cTop = clientRect.top / transformScale;\n    const pTop = parentRect.top / transformScale;\n    newPosition.left = cLeft - pLeft + offsetParent.scrollLeft;\n    newPosition.top = cTop - pTop + offsetParent.scrollTop;\n    this.setState({ dragging: newPosition });\n\n    // Call callback with this data\n    const { x, y } = calcXY(\n      this.getPositionParams(),\n      newPosition.top,\n      newPosition.left,\n      this.props.w,\n      this.props.h\n    );\n\n    return onDragStart.call(this, this.props.i, x, y, {\n      e,\n      node,\n      newPosition\n    });\n  };\n\n  /**\n   * onDrag event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node, delta and position information\n   */\n  onDrag: (Event, ReactDraggableCallbackData) => void = (\n    e,\n    { node, deltaX, deltaY }\n  ) => {\n    const { onDrag } = this.props;\n    if (!onDrag) return;\n\n    if (!this.state.dragging) {\n      throw new Error(\"onDrag called before onDragStart.\");\n    }\n    let top = this.state.dragging.top + deltaY;\n    let left = this.state.dragging.left + deltaX;\n\n    const { isBounded, i, w, h, containerWidth } = this.props;\n    const positionParams = this.getPositionParams();\n\n    // Boundary calculations; keeps items within the grid\n    if (isBounded) {\n      const { offsetParent } = node;\n\n      if (offsetParent) {\n        const { margin, rowHeight } = this.props;\n        const bottomBoundary =\n          offsetParent.clientHeight - calcGridItemWHPx(h, rowHeight, margin[1]);\n        top = clamp(top, 0, bottomBoundary);\n\n        const colWidth = calcGridColWidth(positionParams);\n        const rightBoundary =\n          containerWidth - calcGridItemWHPx(w, colWidth, margin[0]);\n        left = clamp(left, 0, rightBoundary);\n      }\n    }\n\n    const newPosition: PartialPosition = { top, left };\n    this.setState({ dragging: newPosition });\n\n    // Call callback with this data\n    const { x, y } = calcXY(positionParams, top, left, w, h);\n    return onDrag.call(this, i, x, y, {\n      e,\n      node,\n      newPosition\n    });\n  };\n\n  /**\n   * onDragStop event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node, delta and position information\n   */\n  onDragStop: (Event, ReactDraggableCallbackData) => void = (e, { node }) => {\n    const { onDragStop } = this.props;\n    if (!onDragStop) return;\n\n    if (!this.state.dragging) {\n      throw new Error(\"onDragEnd called before onDragStart.\");\n    }\n    const { w, h, i } = this.props;\n    const { left, top } = this.state.dragging;\n    const newPosition: PartialPosition = { top, left };\n    this.setState({ dragging: null });\n\n    const { x, y } = calcXY(this.getPositionParams(), top, left, w, h);\n\n    return onDragStop.call(this, i, x, y, {\n      e,\n      node,\n      newPosition\n    });\n  };\n\n  /**\n   * onResizeStop event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node and size information\n   */\n  onResizeStop: (Event, { node: HTMLElement, size: Position }) => void = (\n    e,\n    callbackData\n  ) => {\n    this.onResizeHandler(e, callbackData, \"onResizeStop\");\n  };\n\n  /**\n   * onResizeStart event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node and size information\n   */\n  onResizeStart: (Event, { node: HTMLElement, size: Position }) => void = (\n    e,\n    callbackData\n  ) => {\n    this.onResizeHandler(e, callbackData, \"onResizeStart\");\n  };\n\n  /**\n   * onResize event handler\n   * @param  {Event}  e             event data\n   * @param  {Object} callbackData  an object with node and size information\n   */\n  onResize: (Event, { node: HTMLElement, size: Position }) => void = (\n    e,\n    callbackData\n  ) => {\n    this.onResizeHandler(e, callbackData, \"onResize\");\n  };\n\n  /**\n   * Wrapper around drag events to provide more useful data.\n   * All drag events call the function with the given handler name,\n   * with the signature (index, x, y).\n   *\n   * @param  {String} handlerName Handler name to wrap.\n   * @return {Function}           Handler function.\n   */\n  onResizeHandler(\n    e: Event,\n    { node, size }: { node: HTMLElement, size: Position },\n    handlerName: string\n  ): void {\n    const handler = this.props[handlerName];\n    if (!handler) return;\n    const { cols, x, y, i, maxH, minH } = this.props;\n    let { minW, maxW } = this.props;\n\n    // Get new XY\n    let { w, h } = calcWH(\n      this.getPositionParams(),\n      size.width,\n      size.height,\n      x,\n      y\n    );\n\n    // minW should be at least 1 (TODO propTypes validation?)\n    minW = Math.max(minW, 1);\n\n    // maxW should be at most (cols - x)\n    maxW = Math.min(maxW, cols - x);\n\n    // Min/max capping\n    w = clamp(w, minW, maxW);\n    h = clamp(h, minH, maxH);\n\n    this.setState({ resizing: handlerName === \"onResizeStop\" ? null : size });\n\n    handler.call(this, i, w, h, { e, node, size });\n  }\n\n  render(): ReactNode {\n    const {\n      x,\n      y,\n      w,\n      h,\n      isDraggable,\n      isResizable,\n      droppingPosition,\n      useCSSTransforms\n    } = this.props;\n\n    const pos = calcGridItemPosition(\n      this.getPositionParams(),\n      x,\n      y,\n      w,\n      h,\n      this.state\n    );\n    const child = React.Children.only(this.props.children);\n\n    // Create the child element. We clone the existing element but modify its className and style.\n    let newChild = React.cloneElement(child, {\n      ref: this.elementRef,\n      className: clsx(\n        \"react-grid-item\",\n        child.props.className,\n        this.props.className,\n        {\n          static: this.props.static,\n          resizing: Boolean(this.state.resizing),\n          \"react-draggable\": isDraggable,\n          \"react-draggable-dragging\": Boolean(this.state.dragging),\n          dropping: Boolean(droppingPosition),\n          cssTransforms: useCSSTransforms\n        }\n      ),\n      // We can set the width and height on the child, but unfortunately we can't set the position.\n      style: {\n        ...this.props.style,\n        ...child.props.style,\n        ...this.createStyle(pos)\n      }\n    });\n\n    // Resizable support. This is usually on but the user can toggle it off.\n    newChild = this.mixinResizable(newChild, pos, isResizable);\n\n    // Draggable support. This is always on, except for with placeholders.\n    newChild = this.mixinDraggable(newChild, isDraggable);\n\n    return newChild;\n  }\n}\n","// @flow\nimport * as React from \"react\";\n\nimport isEqual from \"lodash.isequal\";\nimport clsx from \"clsx\";\nimport {\n  bottom,\n  childrenEqual,\n  cloneLayoutItem,\n  compact,\n  compactType,\n  fastRGLPropsEqual,\n  getAllCollisions,\n  getLayoutItem,\n  moveElement,\n  noop,\n  synchronizeLayoutWithChildren,\n  withLayoutItem\n} from \"./utils\";\n\nimport { calcXY } from \"./calculateUtils\";\n\nimport GridItem from \"./GridItem\";\nimport ReactGridLayoutPropTypes from \"./ReactGridLayoutPropTypes\";\nimport type {\n  ChildrenArray as ReactChildrenArray,\n  Element as ReactElement\n} from \"react\";\n\n// Types\nimport type {\n  CompactType,\n  GridResizeEvent,\n  GridDragEvent,\n  DragOverEvent,\n  Layout,\n  DroppingPosition,\n  LayoutItem\n} from \"./utils\";\n\nimport type { PositionParams } from \"./calculateUtils\";\n\ntype State = {\n  activeDrag: ?LayoutItem,\n  layout: Layout,\n  mounted: boolean,\n  oldDragItem: ?LayoutItem,\n  oldLayout: ?Layout,\n  oldResizeItem: ?LayoutItem,\n  droppingDOMNode: ?ReactElement<any>,\n  droppingPosition?: DroppingPosition,\n  // Mirrored props\n  children: ReactChildrenArray<ReactElement<any>>,\n  compactType?: CompactType,\n  propsLayout?: Layout\n};\n\nimport type { Props, DefaultProps } from \"./ReactGridLayoutPropTypes\";\n\n// End Types\n\nconst layoutClassName = \"react-grid-layout\";\nlet isFirefox = false;\n// Try...catch will protect from navigator not existing (e.g. node) or a bad implementation of navigator\ntry {\n  isFirefox = /firefox/i.test(navigator.userAgent);\n} catch (e) {\n  /* Ignore */\n}\n\n/**\n * A reactive, fluid grid layout with draggable, resizable components.\n */\n\nexport default class ReactGridLayout extends React.Component<Props, State> {\n  // TODO publish internal ReactClass displayName transform\n  static displayName: ?string = \"ReactGridLayout\";\n\n  // Refactored to another module to make way for preval\n  static propTypes = ReactGridLayoutPropTypes;\n\n  static defaultProps: DefaultProps = {\n    autoSize: true,\n    cols: 12,\n    className: \"\",\n    style: {},\n    draggableHandle: \"\",\n    draggableCancel: \"\",\n    containerPadding: null,\n    rowHeight: 150,\n    maxRows: Infinity, // infinite vertical growth\n    layout: [],\n    margin: [10, 10],\n    isBounded: false,\n    isDraggable: true,\n    isResizable: true,\n    allowOverlap: false,\n    isDroppable: false,\n    useCSSTransforms: true,\n    transformScale: 1,\n    verticalCompact: true,\n    compactType: \"vertical\",\n    preventCollision: false,\n    droppingItem: {\n      i: \"__dropping-elem__\",\n      h: 1,\n      w: 1\n    },\n    resizeHandles: [\"se\"],\n    onLayoutChange: noop,\n    onDragStart: noop,\n    onDrag: noop,\n    onDragStop: noop,\n    onResizeStart: noop,\n    onResize: noop,\n    onResizeStop: noop,\n    onDrop: noop,\n    onDropDragOver: noop\n  };\n\n  state: State = {\n    activeDrag: null,\n    layout: synchronizeLayoutWithChildren(\n      this.props.layout,\n      this.props.children,\n      this.props.cols,\n      // Legacy support for verticalCompact: false\n      compactType(this.props),\n      this.props.allowOverlap\n    ),\n    mounted: false,\n    oldDragItem: null,\n    oldLayout: null,\n    oldResizeItem: null,\n    droppingDOMNode: null,\n    children: []\n  };\n\n  dragEnterCounter: number = 0;\n\n  componentDidMount() {\n    this.setState({ mounted: true });\n    // Possibly call back with layout on mount. This should be done after correcting the layout width\n    // to ensure we don't rerender with the wrong width.\n    this.onLayoutMaybeChanged(this.state.layout, this.props.layout);\n  }\n\n  static getDerivedStateFromProps(\n    nextProps: Props,\n    prevState: State\n  ): $Shape<State> | null {\n    let newLayoutBase;\n\n    if (prevState.activeDrag) {\n      return null;\n    }\n\n    // Legacy support for compactType\n    // Allow parent to set layout directly.\n    if (\n      !isEqual(nextProps.layout, prevState.propsLayout) ||\n      nextProps.compactType !== prevState.compactType\n    ) {\n      newLayoutBase = nextProps.layout;\n    } else if (!childrenEqual(nextProps.children, prevState.children)) {\n      // If children change, also regenerate the layout. Use our state\n      // as the base in case because it may be more up to date than\n      // what is in props.\n      newLayoutBase = prevState.layout;\n    }\n\n    // We need to regenerate the layout.\n    if (newLayoutBase) {\n      const newLayout = synchronizeLayoutWithChildren(\n        newLayoutBase,\n        nextProps.children,\n        nextProps.cols,\n        compactType(nextProps),\n        nextProps.allowOverlap\n      );\n\n      return {\n        layout: newLayout,\n        // We need to save these props to state for using\n        // getDerivedStateFromProps instead of componentDidMount (in which we would get extra rerender)\n        compactType: nextProps.compactType,\n        children: nextProps.children,\n        propsLayout: nextProps.layout\n      };\n    }\n\n    return null;\n  }\n\n  shouldComponentUpdate(nextProps: Props, nextState: State): boolean {\n    return (\n      // NOTE: this is almost always unequal. Therefore the only way to get better performance\n      // from SCU is if the user intentionally memoizes children. If they do, and they can\n      // handle changes properly, performance will increase.\n      this.props.children !== nextProps.children ||\n      !fastRGLPropsEqual(this.props, nextProps, isEqual) ||\n      this.state.activeDrag !== nextState.activeDrag ||\n      this.state.mounted !== nextState.mounted ||\n      this.state.droppingPosition !== nextState.droppingPosition\n    );\n  }\n\n  componentDidUpdate(prevProps: Props, prevState: State) {\n    if (!this.state.activeDrag) {\n      const newLayout = this.state.layout;\n      const oldLayout = prevState.layout;\n\n      this.onLayoutMaybeChanged(newLayout, oldLayout);\n    }\n  }\n\n  /**\n   * Calculates a pixel value for the container.\n   * @return {String} Container height in pixels.\n   */\n  containerHeight(): ?string {\n    if (!this.props.autoSize) return;\n    const nbRow = bottom(this.state.layout);\n    const containerPaddingY = this.props.containerPadding\n      ? this.props.containerPadding[1]\n      : this.props.margin[1];\n    return (\n      nbRow * this.props.rowHeight +\n      (nbRow - 1) * this.props.margin[1] +\n      containerPaddingY * 2 +\n      \"px\"\n    );\n  }\n\n  /**\n   * When dragging starts\n   * @param {String} i Id of the child\n   * @param {Number} x X position of the move\n   * @param {Number} y Y position of the move\n   * @param {Event} e The mousedown event\n   * @param {Element} node The current dragging DOM element\n   */\n  onDragStart: (i: string, x: number, y: number, GridDragEvent) => void = (\n    i: string,\n    x: number,\n    y: number,\n    { e, node }: GridDragEvent\n  ) => {\n    const { layout } = this.state;\n    const l = getLayoutItem(layout, i);\n    if (!l) return;\n\n    this.setState({\n      oldDragItem: cloneLayoutItem(l),\n      oldLayout: layout\n    });\n\n    return this.props.onDragStart(layout, l, l, null, e, node);\n  };\n\n  /**\n   * Each drag movement create a new dragelement and move the element to the dragged location\n   * @param {String} i Id of the child\n   * @param {Number} x X position of the move\n   * @param {Number} y Y position of the move\n   * @param {Event} e The mousedown event\n   * @param {Element} node The current dragging DOM element\n   */\n  onDrag: (i: string, x: number, y: number, GridDragEvent) => void = (\n    i,\n    x,\n    y,\n    { e, node }\n  ) => {\n    const { oldDragItem } = this.state;\n    let { layout } = this.state;\n    const { cols, allowOverlap, preventCollision } = this.props;\n    const l = getLayoutItem(layout, i);\n    if (!l) return;\n\n    // Create placeholder (display only)\n    const placeholder = {\n      w: l.w,\n      h: l.h,\n      x: l.x,\n      y: l.y,\n      placeholder: true,\n      i: i\n    };\n\n    // Move the element to the dragged location.\n    const isUserAction = true;\n    layout = moveElement(\n      layout,\n      l,\n      x,\n      y,\n      isUserAction,\n      preventCollision,\n      compactType(this.props),\n      cols,\n      allowOverlap\n    );\n\n    this.props.onDrag(layout, oldDragItem, l, placeholder, e, node);\n\n    this.setState({\n      layout: allowOverlap\n        ? layout\n        : compact(layout, compactType(this.props), cols),\n      activeDrag: placeholder\n    });\n  };\n\n  /**\n   * When dragging stops, figure out which position the element is closest to and update its x and y.\n   * @param  {String} i Index of the child.\n   * @param {Number} x X position of the move\n   * @param {Number} y Y position of the move\n   * @param {Event} e The mousedown event\n   * @param {Element} node The current dragging DOM element\n   */\n  onDragStop: (i: string, x: number, y: number, GridDragEvent) => void = (\n    i,\n    x,\n    y,\n    { e, node }\n  ) => {\n    if (!this.state.activeDrag) return;\n\n    const { oldDragItem } = this.state;\n    let { layout } = this.state;\n    const { cols, preventCollision, allowOverlap } = this.props;\n    const l = getLayoutItem(layout, i);\n    if (!l) return;\n\n    // Move the element here\n    const isUserAction = true;\n    layout = moveElement(\n      layout,\n      l,\n      x,\n      y,\n      isUserAction,\n      preventCollision,\n      compactType(this.props),\n      cols,\n      allowOverlap\n    );\n\n    this.props.onDragStop(layout, oldDragItem, l, null, e, node);\n\n    // Set state\n    const newLayout = allowOverlap\n      ? layout\n      : compact(layout, compactType(this.props), cols);\n    const { oldLayout } = this.state;\n    this.setState({\n      activeDrag: null,\n      layout: newLayout,\n      oldDragItem: null,\n      oldLayout: null\n    });\n\n    this.onLayoutMaybeChanged(newLayout, oldLayout);\n  };\n\n  onLayoutMaybeChanged(newLayout: Layout, oldLayout: ?Layout) {\n    if (!oldLayout) oldLayout = this.state.layout;\n\n    if (!isEqual(oldLayout, newLayout)) {\n      this.props.onLayoutChange(newLayout);\n    }\n  }\n\n  onResizeStart: (i: string, w: number, h: number, GridResizeEvent) => void = (\n    i,\n    w,\n    h,\n    { e, node }\n  ) => {\n    const { layout } = this.state;\n    const l = getLayoutItem(layout, i);\n    if (!l) return;\n\n    this.setState({\n      oldResizeItem: cloneLayoutItem(l),\n      oldLayout: this.state.layout\n    });\n\n    this.props.onResizeStart(layout, l, l, null, e, node);\n  };\n\n  onResize: (i: string, w: number, h: number, GridResizeEvent) => void = (\n    i,\n    w,\n    h,\n    { e, node }\n  ) => {\n    const { layout, oldResizeItem } = this.state;\n    const { cols, preventCollision, allowOverlap } = this.props;\n\n    const [newLayout, l] = withLayoutItem(layout, i, l => {\n      // Something like quad tree should be used\n      // to find collisions faster\n      let hasCollisions;\n      if (preventCollision && !allowOverlap) {\n        const collisions = getAllCollisions(layout, { ...l, w, h }).filter(\n          layoutItem => layoutItem.i !== l.i\n        );\n        hasCollisions = collisions.length > 0;\n\n        // If we're colliding, we need adjust the placeholder.\n        if (hasCollisions) {\n          // adjust w && h to maximum allowed space\n          let leastX = Infinity,\n            leastY = Infinity;\n          collisions.forEach(layoutItem => {\n            if (layoutItem.x > l.x) leastX = Math.min(leastX, layoutItem.x);\n            if (layoutItem.y > l.y) leastY = Math.min(leastY, layoutItem.y);\n          });\n\n          if (Number.isFinite(leastX)) l.w = leastX - l.x;\n          if (Number.isFinite(leastY)) l.h = leastY - l.y;\n        }\n      }\n\n      if (!hasCollisions) {\n        // Set new width and height.\n        l.w = w;\n        l.h = h;\n      }\n\n      return l;\n    });\n\n    // Shouldn't ever happen, but typechecking makes it necessary\n    if (!l) return;\n\n    // Create placeholder element (display only)\n    const placeholder = {\n      w: l.w,\n      h: l.h,\n      x: l.x,\n      y: l.y,\n      static: true,\n      i: i\n    };\n\n    this.props.onResize(newLayout, oldResizeItem, l, placeholder, e, node);\n\n    // Re-compact the newLayout and set the drag placeholder.\n    this.setState({\n      layout: allowOverlap\n        ? newLayout\n        : compact(newLayout, compactType(this.props), cols),\n      activeDrag: placeholder\n    });\n  };\n\n  onResizeStop: (i: string, w: number, h: number, GridResizeEvent) => void = (\n    i,\n    w,\n    h,\n    { e, node }\n  ) => {\n    const { layout, oldResizeItem } = this.state;\n    const { cols, allowOverlap } = this.props;\n    const l = getLayoutItem(layout, i);\n\n    this.props.onResizeStop(layout, oldResizeItem, l, null, e, node);\n\n    // Set state\n    const newLayout = allowOverlap\n      ? layout\n      : compact(layout, compactType(this.props), cols);\n    const { oldLayout } = this.state;\n    this.setState({\n      activeDrag: null,\n      layout: newLayout,\n      oldResizeItem: null,\n      oldLayout: null\n    });\n\n    this.onLayoutMaybeChanged(newLayout, oldLayout);\n  };\n\n  /**\n   * Create a placeholder object.\n   * @return {Element} Placeholder div.\n   */\n  placeholder(): ?ReactElement<any> {\n    const { activeDrag } = this.state;\n    if (!activeDrag) return null;\n    const {\n      width,\n      cols,\n      margin,\n      containerPadding,\n      rowHeight,\n      maxRows,\n      useCSSTransforms,\n      transformScale\n    } = this.props;\n\n    // {...this.state.activeDrag} is pretty slow, actually\n    return (\n      <GridItem\n        w={activeDrag.w}\n        h={activeDrag.h}\n        x={activeDrag.x}\n        y={activeDrag.y}\n        i={activeDrag.i}\n        className=\"react-grid-placeholder\"\n        containerWidth={width}\n        cols={cols}\n        margin={margin}\n        containerPadding={containerPadding || margin}\n        maxRows={maxRows}\n        rowHeight={rowHeight}\n        isDraggable={false}\n        isResizable={false}\n        isBounded={false}\n        useCSSTransforms={useCSSTransforms}\n        transformScale={transformScale}\n      >\n        <div />\n      </GridItem>\n    );\n  }\n\n  /**\n   * Given a grid item, set its style attributes & surround in a <Draggable>.\n   * @param  {Element} child React element.\n   * @return {Element}       Element wrapped in draggable and properly placed.\n   */\n  processGridItem(\n    child: ReactElement<any>,\n    isDroppingItem?: boolean\n  ): ?ReactElement<any> {\n    if (!child || !child.key) return;\n    const l = getLayoutItem(this.state.layout, String(child.key));\n    if (!l) return null;\n    const {\n      width,\n      cols,\n      margin,\n      containerPadding,\n      rowHeight,\n      maxRows,\n      isDraggable,\n      isResizable,\n      isBounded,\n      useCSSTransforms,\n      transformScale,\n      draggableCancel,\n      draggableHandle,\n      resizeHandles,\n      resizeHandle\n    } = this.props;\n    const { mounted, droppingPosition } = this.state;\n\n    // Determine user manipulations possible.\n    // If an item is static, it can't be manipulated by default.\n    // Any properties defined directly on the grid item will take precedence.\n    const draggable =\n      typeof l.isDraggable === \"boolean\"\n        ? l.isDraggable\n        : !l.static && isDraggable;\n    const resizable =\n      typeof l.isResizable === \"boolean\"\n        ? l.isResizable\n        : !l.static && isResizable;\n    const resizeHandlesOptions = l.resizeHandles || resizeHandles;\n\n    // isBounded set on child if set on parent, and child is not explicitly false\n    const bounded = draggable && isBounded && l.isBounded !== false;\n\n    return (\n      <GridItem\n        containerWidth={width}\n        cols={cols}\n        margin={margin}\n        containerPadding={containerPadding || margin}\n        maxRows={maxRows}\n        rowHeight={rowHeight}\n        cancel={draggableCancel}\n        handle={draggableHandle}\n        onDragStop={this.onDragStop}\n        onDragStart={this.onDragStart}\n        onDrag={this.onDrag}\n        onResizeStart={this.onResizeStart}\n        onResize={this.onResize}\n        onResizeStop={this.onResizeStop}\n        isDraggable={draggable}\n        isResizable={resizable}\n        isBounded={bounded}\n        useCSSTransforms={useCSSTransforms && mounted}\n        usePercentages={!mounted}\n        transformScale={transformScale}\n        w={l.w}\n        h={l.h}\n        x={l.x}\n        y={l.y}\n        i={l.i}\n        minH={l.minH}\n        minW={l.minW}\n        maxH={l.maxH}\n        maxW={l.maxW}\n        static={l.static}\n        droppingPosition={isDroppingItem ? droppingPosition : undefined}\n        resizeHandles={resizeHandlesOptions}\n        resizeHandle={resizeHandle}\n      >\n        {child}\n      </GridItem>\n    );\n  }\n\n  // Called while dragging an element. Part of browser native drag/drop API.\n  // Native event target might be the layout itself, or an element within the layout.\n  onDragOver: DragOverEvent => void | false = e => {\n    e.preventDefault(); // Prevent any browser native action\n    e.stopPropagation();\n\n    // we should ignore events from layout's children in Firefox\n    // to avoid unpredictable jumping of a dropping placeholder\n    // FIXME remove this hack\n    if (\n      isFirefox &&\n      // $FlowIgnore can't figure this out\n      !e.nativeEvent.target?.classList.contains(layoutClassName)\n    ) {\n      return false;\n    }\n\n    const {\n      droppingItem,\n      onDropDragOver,\n      margin,\n      cols,\n      rowHeight,\n      maxRows,\n      width,\n      containerPadding,\n      transformScale\n    } = this.props;\n    // Allow user to customize the dropping item or short-circuit the drop based on the results\n    // of the `onDragOver(e: Event)` callback.\n    const onDragOverResult = onDropDragOver?.(e);\n    if (onDragOverResult === false) {\n      if (this.state.droppingDOMNode) {\n        this.removeDroppingPlaceholder();\n      }\n      return false;\n    }\n    const finalDroppingItem = { ...droppingItem, ...onDragOverResult };\n\n    const { layout } = this.state;\n    // This is relative to the DOM element that this event fired for.\n    const { layerX, layerY } = e.nativeEvent;\n    const droppingPosition = {\n      left: layerX / transformScale,\n      top: layerY / transformScale,\n      e\n    };\n\n    if (!this.state.droppingDOMNode) {\n      const positionParams: PositionParams = {\n        cols,\n        margin,\n        maxRows,\n        rowHeight,\n        containerWidth: width,\n        containerPadding: containerPadding || margin\n      };\n\n      const calculatedPosition = calcXY(\n        positionParams,\n        layerY,\n        layerX,\n        finalDroppingItem.w,\n        finalDroppingItem.h\n      );\n\n      this.setState({\n        droppingDOMNode: <div key={finalDroppingItem.i} />,\n        droppingPosition,\n        layout: [\n          ...layout,\n          {\n            ...finalDroppingItem,\n            x: calculatedPosition.x,\n            y: calculatedPosition.y,\n            static: false,\n            isDraggable: true\n          }\n        ]\n      });\n    } else if (this.state.droppingPosition) {\n      const { left, top } = this.state.droppingPosition;\n      const shouldUpdatePosition = left != layerX || top != layerY;\n      if (shouldUpdatePosition) {\n        this.setState({ droppingPosition });\n      }\n    }\n  };\n\n  removeDroppingPlaceholder: () => void = () => {\n    const { droppingItem, cols } = this.props;\n    const { layout } = this.state;\n\n    const newLayout = compact(\n      layout.filter(l => l.i !== droppingItem.i),\n      compactType(this.props),\n      cols\n    );\n\n    this.setState({\n      layout: newLayout,\n      droppingDOMNode: null,\n      activeDrag: null,\n      droppingPosition: undefined\n    });\n  };\n\n  onDragLeave: EventHandler = e => {\n    e.preventDefault(); // Prevent any browser native action\n    this.dragEnterCounter--;\n\n    // onDragLeave can be triggered on each layout's child.\n    // But we know that count of dragEnter and dragLeave events\n    // will be balanced after leaving the layout's container\n    // so we can increase and decrease count of dragEnter and\n    // when it'll be equal to 0 we'll remove the placeholder\n    if (this.dragEnterCounter === 0) {\n      this.removeDroppingPlaceholder();\n    }\n  };\n\n  onDragEnter: EventHandler = e => {\n    e.preventDefault(); // Prevent any browser native action\n    this.dragEnterCounter++;\n  };\n\n  onDrop: EventHandler = (e: Event) => {\n    e.preventDefault(); // Prevent any browser native action\n    const { droppingItem } = this.props;\n    const { layout } = this.state;\n    const item = layout.find(l => l.i === droppingItem.i);\n\n    // reset dragEnter counter on drop\n    this.dragEnterCounter = 0;\n\n    this.removeDroppingPlaceholder();\n\n    this.props.onDrop(layout, item, e);\n  };\n\n  render(): React.Element<\"div\"> {\n    const { className, style, isDroppable, innerRef } = this.props;\n\n    const mergedClassName = clsx(layoutClassName, className);\n    const mergedStyle = {\n      height: this.containerHeight(),\n      ...style\n    };\n\n    return (\n      <div\n        ref={innerRef}\n        className={mergedClassName}\n        style={mergedStyle}\n        onDrop={isDroppable ? this.onDrop : noop}\n        onDragLeave={isDroppable ? this.onDragLeave : noop}\n        onDragEnter={isDroppable ? this.onDragEnter : noop}\n        onDragOver={isDroppable ? this.onDragOver : noop}\n      >\n        {React.Children.map(this.props.children, child =>\n          this.processGridItem(child)\n        )}\n        {isDroppable &&\n          this.state.droppingDOMNode &&\n          this.processGridItem(this.state.droppingDOMNode, true)}\n        {this.placeholder()}\n      </div>\n    );\n  }\n}\n","// @flow\nimport * as React from \"react\";\nimport PropTypes from \"prop-types\";\nimport isEqual from \"lodash.isequal\";\n\nimport {\n  cloneLayout,\n  synchronizeLayoutWithChildren,\n  validateLayout,\n  noop,\n  type Layout,\n  type Pick\n} from \"./utils\";\nimport {\n  getBreakpointFromWidth,\n  getColsFromBreakpoint,\n  findOrGenerateResponsiveLayout,\n  type ResponsiveLayout,\n  type OnLayoutChangeCallback,\n  type Breakpoints\n} from \"./responsiveUtils\";\nimport ReactGridLayout from \"./ReactGridLayout\";\n\n// $FlowFixMe[method-unbinding]\nconst type = obj => Object.prototype.toString.call(obj);\n\n/**\n * Get a value of margin or containerPadding.\n *\n * @param  {Array | Object} param Margin | containerPadding, e.g. [10, 10] | {lg: [10, 10], ...}.\n * @param  {String} breakpoint   Breakpoint: lg, md, sm, xs and etc.\n * @return {Array}\n */\nfunction getIndentationValue<T: ?[number, number]>(\n  param: { [key: string]: T } | T,\n  breakpoint: string\n): T {\n  // $FlowIgnore TODO fix this typedef\n  if (param == null) return null;\n  // $FlowIgnore TODO fix this typedef\n  return Array.isArray(param) ? param : param[breakpoint];\n}\n\ntype State = {\n  layout: Layout,\n  breakpoint: string,\n  cols: number,\n  layouts?: ResponsiveLayout<string>\n};\n\ntype Props<Breakpoint: string = string> = {|\n  ...React.ElementConfig<typeof ReactGridLayout>,\n\n  // Responsive config\n  breakpoint?: ?Breakpoint,\n  breakpoints: Breakpoints<Breakpoint>,\n  cols: { [key: Breakpoint]: number },\n  layouts: ResponsiveLayout<Breakpoint>,\n  width: number,\n  margin: { [key: Breakpoint]: [number, number] } | [number, number],\n  /* prettier-ignore */\n  containerPadding: { [key: Breakpoint]: ?[number, number] } | ?[number, number],\n\n  // Callbacks\n  onBreakpointChange: (Breakpoint, cols: number) => void,\n  onLayoutChange: OnLayoutChangeCallback,\n  onWidthChange: (\n    containerWidth: number,\n    margin: [number, number],\n    cols: number,\n    containerPadding: ?[number, number]\n  ) => void\n|};\n\ntype DefaultProps = Pick<\n  Props<>,\n  {|\n    allowOverlap: 0,\n    breakpoints: 0,\n    cols: 0,\n    containerPadding: 0,\n    layouts: 0,\n    margin: 0,\n    onBreakpointChange: 0,\n    onLayoutChange: 0,\n    onWidthChange: 0\n  |}\n>;\n\nexport default class ResponsiveReactGridLayout extends React.Component<\n  Props<>,\n  State\n> {\n  // This should only include propTypes needed in this code; RGL itself\n  // will do validation of the rest props passed to it.\n  static propTypes = {\n    //\n    // Basic props\n    //\n\n    // Optional, but if you are managing width yourself you may want to set the breakpoint\n    // yourself as well.\n    breakpoint: PropTypes.string,\n\n    // {name: pxVal}, e.g. {lg: 1200, md: 996, sm: 768, xs: 480}\n    breakpoints: PropTypes.object,\n\n    allowOverlap: PropTypes.bool,\n\n    // # of cols. This is a breakpoint -> cols map\n    cols: PropTypes.object,\n\n    // # of margin. This is a breakpoint -> margin map\n    // e.g. { lg: [5, 5], md: [10, 10], sm: [15, 15] }\n    // Margin between items [x, y] in px\n    // e.g. [10, 10]\n    margin: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),\n\n    // # of containerPadding. This is a breakpoint -> containerPadding map\n    // e.g. { lg: [5, 5], md: [10, 10], sm: [15, 15] }\n    // Padding inside the container [x, y] in px\n    // e.g. [10, 10]\n    containerPadding: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),\n\n    // layouts is an object mapping breakpoints to layouts.\n    // e.g. {lg: Layout, md: Layout, ...}\n    layouts(props: Props<>, propName: string) {\n      if (type(props[propName]) !== \"[object Object]\") {\n        throw new Error(\n          \"Layout property must be an object. Received: \" +\n            type(props[propName])\n        );\n      }\n      Object.keys(props[propName]).forEach(key => {\n        if (!(key in props.breakpoints)) {\n          throw new Error(\n            \"Each key in layouts must align with a key in breakpoints.\"\n          );\n        }\n        validateLayout(props.layouts[key], \"layouts.\" + key);\n      });\n    },\n\n    // The width of this component.\n    // Required in this propTypes stanza because generateInitialState() will fail without it.\n    width: PropTypes.number.isRequired,\n\n    //\n    // Callbacks\n    //\n\n    // Calls back with breakpoint and new # cols\n    onBreakpointChange: PropTypes.func,\n\n    // Callback so you can save the layout.\n    // Calls back with (currentLayout, allLayouts). allLayouts are keyed by breakpoint.\n    onLayoutChange: PropTypes.func,\n\n    // Calls back with (containerWidth, margin, cols, containerPadding)\n    onWidthChange: PropTypes.func\n  };\n\n  static defaultProps: DefaultProps = {\n    breakpoints: { lg: 1200, md: 996, sm: 768, xs: 480, xxs: 0 },\n    cols: { lg: 12, md: 10, sm: 6, xs: 4, xxs: 2 },\n    containerPadding: { lg: null, md: null, sm: null, xs: null, xxs: null },\n    layouts: {},\n    margin: [10, 10],\n    allowOverlap: false,\n    onBreakpointChange: noop,\n    onLayoutChange: noop,\n    onWidthChange: noop\n  };\n\n  state: State = this.generateInitialState();\n\n  generateInitialState(): State {\n    const { width, breakpoints, layouts, cols } = this.props;\n    const breakpoint = getBreakpointFromWidth(breakpoints, width);\n    const colNo = getColsFromBreakpoint(breakpoint, cols);\n    // verticalCompact compatibility, now deprecated\n    const compactType =\n      this.props.verticalCompact === false ? null : this.props.compactType;\n    // Get the initial layout. This can tricky; we try to generate one however possible if one doesn't exist\n    // for this layout.\n    const initialLayout = findOrGenerateResponsiveLayout(\n      layouts,\n      breakpoints,\n      breakpoint,\n      breakpoint,\n      colNo,\n      compactType\n    );\n\n    return {\n      layout: initialLayout,\n      breakpoint: breakpoint,\n      cols: colNo\n    };\n  }\n\n  static getDerivedStateFromProps(\n    nextProps: Props<*>,\n    prevState: State\n  ): ?$Shape<State> {\n    if (!isEqual(nextProps.layouts, prevState.layouts)) {\n      // Allow parent to set layouts directly.\n      const { breakpoint, cols } = prevState;\n\n      // Since we're setting an entirely new layout object, we must generate a new responsive layout\n      // if one does not exist.\n      const newLayout = findOrGenerateResponsiveLayout(\n        nextProps.layouts,\n        nextProps.breakpoints,\n        breakpoint,\n        breakpoint,\n        cols,\n        nextProps.compactType\n      );\n      return { layout: newLayout, layouts: nextProps.layouts };\n    }\n\n    return null;\n  }\n\n  componentDidUpdate(prevProps: Props<*>) {\n    // Allow parent to set width or breakpoint directly.\n    if (\n      this.props.width != prevProps.width ||\n      this.props.breakpoint !== prevProps.breakpoint ||\n      !isEqual(this.props.breakpoints, prevProps.breakpoints) ||\n      !isEqual(this.props.cols, prevProps.cols)\n    ) {\n      this.onWidthChange(prevProps);\n    }\n  }\n\n  // wrap layouts so we do not need to pass layouts to child\n  onLayoutChange: Layout => void = (layout: Layout) => {\n    this.props.onLayoutChange(layout, {\n      ...this.props.layouts,\n      [this.state.breakpoint]: layout\n    });\n  };\n\n  /**\n   * When the width changes work through breakpoints and reset state with the new width & breakpoint.\n   * Width changes are necessary to figure out the widget widths.\n   */\n  onWidthChange(prevProps: Props<*>) {\n    const { breakpoints, cols, layouts, compactType } = this.props;\n    const newBreakpoint =\n      this.props.breakpoint ||\n      getBreakpointFromWidth(this.props.breakpoints, this.props.width);\n\n    const lastBreakpoint = this.state.breakpoint;\n    const newCols: number = getColsFromBreakpoint(newBreakpoint, cols);\n    const newLayouts = { ...layouts };\n\n    // Breakpoint change\n    if (\n      lastBreakpoint !== newBreakpoint ||\n      prevProps.breakpoints !== breakpoints ||\n      prevProps.cols !== cols\n    ) {\n      // Preserve the current layout if the current breakpoint is not present in the next layouts.\n      if (!(lastBreakpoint in newLayouts))\n        newLayouts[lastBreakpoint] = cloneLayout(this.state.layout);\n\n      // Find or generate a new layout.\n      let layout = findOrGenerateResponsiveLayout(\n        newLayouts,\n        breakpoints,\n        newBreakpoint,\n        lastBreakpoint,\n        newCols,\n        compactType\n      );\n\n      // This adds missing items.\n      layout = synchronizeLayoutWithChildren(\n        layout,\n        this.props.children,\n        newCols,\n        compactType,\n        this.props.allowOverlap\n      );\n\n      // Store the new layout.\n      newLayouts[newBreakpoint] = layout;\n\n      // callbacks\n      this.props.onLayoutChange(layout, newLayouts);\n      this.props.onBreakpointChange(newBreakpoint, newCols);\n\n      this.setState({\n        breakpoint: newBreakpoint,\n        layout: layout,\n        cols: newCols\n      });\n    }\n\n    const margin = getIndentationValue(this.props.margin, newBreakpoint);\n    const containerPadding = getIndentationValue(\n      this.props.containerPadding,\n      newBreakpoint\n    );\n\n    //call onWidthChange on every change of width, not only on breakpoint changes\n    this.props.onWidthChange(\n      this.props.width,\n      margin,\n      newCols,\n      containerPadding\n    );\n  }\n\n  render(): React.Element<typeof ReactGridLayout> {\n    /* eslint-disable no-unused-vars */\n    const {\n      breakpoint,\n      breakpoints,\n      cols,\n      layouts,\n      margin,\n      containerPadding,\n      onBreakpointChange,\n      onLayoutChange,\n      onWidthChange,\n      ...other\n    } = this.props;\n    /* eslint-enable no-unused-vars */\n\n    return (\n      <ReactGridLayout\n        {...other}\n        // $FlowIgnore should allow nullable here due to DefaultProps\n        margin={getIndentationValue(margin, this.state.breakpoint)}\n        containerPadding={getIndentationValue(\n          containerPadding,\n          this.state.breakpoint\n        )}\n        onLayoutChange={this.onLayoutChange}\n        layout={this.state.layout}\n        cols={this.state.cols}\n      />\n    );\n  }\n}\n","// @flow\nimport * as React from \"react\";\nimport PropTypes from \"prop-types\";\nimport clsx from \"clsx\";\nimport type { ReactRef } from \"../ReactGridLayoutPropTypes\";\n\ntype WPDefaultProps = {|\n  measureBeforeMount: boolean\n|};\n\n// eslint-disable-next-line no-unused-vars\ntype WPProps = {|\n  className?: string,\n  style?: Object,\n  ...WPDefaultProps\n|};\n\ntype WPState = {|\n  width: number\n|};\n\ntype ComposedProps<Config> = {|\n  ...Config,\n  measureBeforeMount?: boolean,\n  className?: string,\n  style?: Object,\n  width?: number\n|};\n\nconst layoutClassName = \"react-grid-layout\";\n\n/*\n * A simple HOC that provides facility for listening to container resizes.\n *\n * The Flow type is pretty janky here. I can't just spread `WPProps` into this returned object - I wish I could - but it triggers\n * a flow bug of some sort that causes it to stop typechecking.\n */\nexport default function WidthProvideRGL<Config>(\n  ComposedComponent: React.AbstractComponent<Config>\n): React.AbstractComponent<ComposedProps<Config>> {\n  return class WidthProvider extends React.Component<\n    ComposedProps<Config>,\n    WPState\n  > {\n    static defaultProps: WPDefaultProps = {\n      measureBeforeMount: false\n    };\n\n    static propTypes = {\n      // If true, will not render children until mounted. Useful for getting the exact width before\n      // rendering, to prevent any unsightly resizing.\n      measureBeforeMount: PropTypes.bool\n    };\n\n    state: WPState = {\n      width: 1280\n    };\n\n    elementRef: ReactRef<HTMLDivElement> = React.createRef();\n    mounted: boolean = false;\n\n    componentDidMount() {\n      this.mounted = true;\n      window.addEventListener(\"resize\", this.onWindowResize);\n      // Call to properly set the breakpoint and resize the elements.\n      // Note that if you're doing a full-width element, this can get a little wonky if a scrollbar\n      // appears because of the grid. In that case, fire your own resize event, or set `overflow: scroll` on your body.\n      this.onWindowResize();\n    }\n\n    componentWillUnmount() {\n      this.mounted = false;\n      window.removeEventListener(\"resize\", this.onWindowResize);\n    }\n\n    onWindowResize = () => {\n      if (!this.mounted) return;\n      const node = this.elementRef.current; // Flow casts this to Text | Element\n      // fix: grid position error when node or parentNode display is none by window resize\n      // #924 #1084\n      if (node instanceof HTMLElement && node.offsetWidth) {\n        this.setState({ width: node.offsetWidth });\n      }\n    };\n\n    render() {\n      const { measureBeforeMount, ...rest } = this.props;\n      if (measureBeforeMount && !this.mounted) {\n        return (\n          <div\n            className={clsx(this.props.className, layoutClassName)}\n            style={this.props.style}\n            // $FlowIgnore ref types\n            ref={this.elementRef}\n          />\n        );\n      }\n\n      return (\n        <ComposedComponent\n          innerRef={this.elementRef}\n          {...rest}\n          {...this.state}\n        />\n      );\n    }\n  };\n}\n","// @flow\n\nimport { cloneLayout, compact, correctBounds } from \"./utils\";\n\nimport type { CompactType, Layout } from \"./utils\";\n\nexport type Breakpoint = string;\nexport type DefaultBreakpoints = \"lg\" | \"md\" | \"sm\" | \"xs\" | \"xxs\";\n\n// + indicates read-only\nexport type ResponsiveLayout<T: Breakpoint> = {\n  +[breakpoint: T]: Layout\n};\nexport type Breakpoints<T: Breakpoint> = {\n  +[breakpoint: T]: number\n};\n\nexport type OnLayoutChangeCallback = (\n  Layout,\n  { [key: Breakpoint]: Layout }\n) => void;\n\n/**\n * Given a width, find the highest breakpoint that matches is valid for it (width > breakpoint).\n *\n * @param  {Object} breakpoints Breakpoints object (e.g. {lg: 1200, md: 960, ...})\n * @param  {Number} width Screen width.\n * @return {String}       Highest breakpoint that is less than width.\n */\nexport function getBreakpointFromWidth(\n  breakpoints: Breakpoints<Breakpoint>,\n  width: number\n): Breakpoint {\n  const sorted = sortBreakpoints(breakpoints);\n  let matching = sorted[0];\n  for (let i = 1, len = sorted.length; i < len; i++) {\n    const breakpointName = sorted[i];\n    if (width > breakpoints[breakpointName]) matching = breakpointName;\n  }\n  return matching;\n}\n\n/**\n * Given a breakpoint, get the # of cols set for it.\n * @param  {String} breakpoint Breakpoint name.\n * @param  {Object} cols       Map of breakpoints to cols.\n * @return {Number}            Number of cols.\n */\nexport function getColsFromBreakpoint(\n  breakpoint: Breakpoint,\n  cols: Breakpoints<Breakpoint>\n): number {\n  if (!cols[breakpoint]) {\n    throw new Error(\n      \"ResponsiveReactGridLayout: `cols` entry for breakpoint \" +\n        breakpoint +\n        \" is missing!\"\n    );\n  }\n  return cols[breakpoint];\n}\n\n/**\n * Given existing layouts and a new breakpoint, find or generate a new layout.\n *\n * This finds the layout above the new one and generates from it, if it exists.\n *\n * @param  {Object} layouts     Existing layouts.\n * @param  {Array} breakpoints All breakpoints.\n * @param  {String} breakpoint New breakpoint.\n * @param  {String} breakpoint Last breakpoint (for fallback).\n * @param  {Number} cols       Column count at new breakpoint.\n * @param  {Boolean} verticalCompact Whether or not to compact the layout\n *   vertically.\n * @return {Array}             New layout.\n */\nexport function findOrGenerateResponsiveLayout(\n  layouts: ResponsiveLayout<Breakpoint>,\n  breakpoints: Breakpoints<Breakpoint>,\n  breakpoint: Breakpoint,\n  lastBreakpoint: Breakpoint,\n  cols: number,\n  compactType: CompactType\n): Layout {\n  // If it already exists, just return it.\n  if (layouts[breakpoint]) return cloneLayout(layouts[breakpoint]);\n  // Find or generate the next layout\n  let layout = layouts[lastBreakpoint];\n  const breakpointsSorted = sortBreakpoints(breakpoints);\n  const breakpointsAbove = breakpointsSorted.slice(\n    breakpointsSorted.indexOf(breakpoint)\n  );\n  for (let i = 0, len = breakpointsAbove.length; i < len; i++) {\n    const b = breakpointsAbove[i];\n    if (layouts[b]) {\n      layout = layouts[b];\n      break;\n    }\n  }\n  layout = cloneLayout(layout || []); // clone layout so we don't modify existing items\n  return compact(correctBounds(layout, { cols: cols }), compactType, cols);\n}\n\n/**\n * Given breakpoints, return an array of breakpoints sorted by width. This is usually\n * e.g. ['xxs', 'xs', 'sm', ...]\n *\n * @param  {Object} breakpoints Key/value pair of breakpoint names to widths.\n * @return {Array}              Sorted breakpoints.\n */\nexport function sortBreakpoints(\n  breakpoints: Breakpoints<Breakpoint>\n): Array<Breakpoint> {\n  const keys: Array<string> = Object.keys(breakpoints);\n  return keys.sort(function (a, b) {\n    return breakpoints[a] - breakpoints[b];\n  });\n}\n","// @flow\nimport isEqual from \"lodash.isequal\";\nimport React from \"react\";\nimport type {\n  ChildrenArray as ReactChildrenArray,\n  Element as ReactElement\n} from \"react\";\nexport type LayoutItem = {\n  w: number,\n  h: number,\n  x: number,\n  y: number,\n  i: string,\n  minW?: number,\n  minH?: number,\n  maxW?: number,\n  maxH?: number,\n  moved?: boolean,\n  static?: boolean,\n  isDraggable?: ?boolean,\n  isResizable?: ?boolean,\n  resizeHandles?: Array<\"s\" | \"w\" | \"e\" | \"n\" | \"sw\" | \"nw\" | \"se\" | \"ne\">,\n  isBounded?: ?boolean\n};\nexport type Layout = $ReadOnlyArray<LayoutItem>;\nexport type Position = {\n  left: number,\n  top: number,\n  width: number,\n  height: number\n};\nexport type ReactDraggableCallbackData = {\n  node: HTMLElement,\n  x?: number,\n  y?: number,\n  deltaX: number,\n  deltaY: number,\n  lastX?: number,\n  lastY?: number\n};\n\nexport type PartialPosition = { left: number, top: number };\nexport type DroppingPosition = { left: number, top: number, e: Event };\nexport type Size = { width: number, height: number };\nexport type GridDragEvent = {\n  e: Event,\n  node: HTMLElement,\n  newPosition: PartialPosition\n};\nexport type GridResizeEvent = { e: Event, node: HTMLElement, size: Size };\nexport type DragOverEvent = MouseEvent & {\n  nativeEvent: {\n    layerX: number,\n    layerY: number,\n    ...Event\n  }\n};\n\n// Helpful port from TS\nexport type Pick<FromType, Properties: { [string]: 0 }> = $Exact<\n  $ObjMapi<Properties, <K, V>(k: K, v: V) => $ElementType<FromType, K>>\n>;\n\ntype REl = ReactElement<any>;\nexport type ReactChildren = ReactChildrenArray<REl>;\n\n// All callbacks are of the signature (layout, oldItem, newItem, placeholder, e).\nexport type EventCallback = (\n  Layout,\n  oldItem: ?LayoutItem,\n  newItem: ?LayoutItem,\n  placeholder: ?LayoutItem,\n  Event,\n  ?HTMLElement\n) => void;\nexport type CompactType = ?(\"horizontal\" | \"vertical\");\n\nconst isProduction = process.env.NODE_ENV === \"production\";\nconst DEBUG = false;\n\n/**\n * Return the bottom coordinate of the layout.\n *\n * @param  {Array} layout Layout array.\n * @return {Number}       Bottom coordinate.\n */\nexport function bottom(layout: Layout): number {\n  let max = 0,\n    bottomY;\n  for (let i = 0, len = layout.length; i < len; i++) {\n    bottomY = layout[i].y + layout[i].h;\n    if (bottomY > max) max = bottomY;\n  }\n  return max;\n}\n\nexport function cloneLayout(layout: Layout): Layout {\n  const newLayout = Array(layout.length);\n  for (let i = 0, len = layout.length; i < len; i++) {\n    newLayout[i] = cloneLayoutItem(layout[i]);\n  }\n  return newLayout;\n}\n\n// Modify a layoutItem inside a layout. Returns a new Layout,\n// does not mutate. Carries over all other LayoutItems unmodified.\nexport function modifyLayout(layout: Layout, layoutItem: LayoutItem): Layout {\n  const newLayout = Array(layout.length);\n  for (let i = 0, len = layout.length; i < len; i++) {\n    if (layoutItem.i === layout[i].i) {\n      newLayout[i] = layoutItem;\n    } else {\n      newLayout[i] = layout[i];\n    }\n  }\n  return newLayout;\n}\n\n// Function to be called to modify a layout item.\n// Does defensive clones to ensure the layout is not modified.\nexport function withLayoutItem(\n  layout: Layout,\n  itemKey: string,\n  cb: LayoutItem => LayoutItem\n): [Layout, ?LayoutItem] {\n  let item = getLayoutItem(layout, itemKey);\n  if (!item) return [layout, null];\n  item = cb(cloneLayoutItem(item)); // defensive clone then modify\n  // FIXME could do this faster if we already knew the index\n  layout = modifyLayout(layout, item);\n  return [layout, item];\n}\n\n// Fast path to cloning, since this is monomorphic\nexport function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem {\n  return {\n    w: layoutItem.w,\n    h: layoutItem.h,\n    x: layoutItem.x,\n    y: layoutItem.y,\n    i: layoutItem.i,\n    minW: layoutItem.minW,\n    maxW: layoutItem.maxW,\n    minH: layoutItem.minH,\n    maxH: layoutItem.maxH,\n    moved: Boolean(layoutItem.moved),\n    static: Boolean(layoutItem.static),\n    // These can be null/undefined\n    isDraggable: layoutItem.isDraggable,\n    isResizable: layoutItem.isResizable,\n    resizeHandles: layoutItem.resizeHandles,\n    isBounded: layoutItem.isBounded\n  };\n}\n\n/**\n * Comparing React `children` is a bit difficult. This is a good way to compare them.\n * This will catch differences in keys, order, and length.\n */\nexport function childrenEqual(a: ReactChildren, b: ReactChildren): boolean {\n  return isEqual(\n    React.Children.map(a, c => c?.key),\n    React.Children.map(b, c => c?.key)\n  );\n}\n\n/**\n * See `fastRGLPropsEqual.js`.\n * We want this to run as fast as possible - it is called often - and to be\n * resilient to new props that we add. So rather than call lodash.isEqual,\n * which isn't suited to comparing props very well, we use this specialized\n * function in conjunction with preval to generate the fastest possible comparison\n * function, tuned for exactly our props.\n */\ntype FastRGLPropsEqual = (Object, Object, Function) => boolean;\nexport const fastRGLPropsEqual: FastRGLPropsEqual = require(\"./fastRGLPropsEqual\");\n\n// Like the above, but a lot simpler.\nexport function fastPositionEqual(a: Position, b: Position): boolean {\n  return (\n    a.left === b.left &&\n    a.top === b.top &&\n    a.width === b.width &&\n    a.height === b.height\n  );\n}\n\n/**\n * Given two layoutitems, check if they collide.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  if (l1.i === l2.i) return false; // same element\n  if (l1.x + l1.w <= l2.x) return false; // l1 is left of l2\n  if (l1.x >= l2.x + l2.w) return false; // l1 is right of l2\n  if (l1.y + l1.h <= l2.y) return false; // l1 is above l2\n  if (l1.y >= l2.y + l2.h) return false; // l1 is below l2\n  return true; // boxes overlap\n}\n\n/**\n * Given a layout, compact it. This involves going down each y coordinate and removing gaps\n * between items.\n *\n * Does not modify layout items (clones). Creates a new layout array.\n *\n * @param  {Array} layout Layout.\n * @param  {Boolean} verticalCompact Whether or not to compact the layout\n *   vertically.\n * @return {Array}       Compacted Layout.\n */\nexport function compact(\n  layout: Layout,\n  compactType: CompactType,\n  cols: number\n): Layout {\n  // Statics go in the compareWith array right away so items flow around them.\n  const compareWith = getStatics(layout);\n  // We go through the items by row and column.\n  const sorted = sortLayoutItems(layout, compactType);\n  // Holding for new items.\n  const out = Array(layout.length);\n\n  for (let i = 0, len = sorted.length; i < len; i++) {\n    let l = cloneLayoutItem(sorted[i]);\n\n    // Don't move static elements\n    if (!l.static) {\n      l = compactItem(compareWith, l, compactType, cols, sorted);\n\n      // Add to comparison array. We only collide with items before this one.\n      // Statics are already in this array.\n      compareWith.push(l);\n    }\n\n    // Add to output array to make sure they still come out in the right order.\n    out[layout.indexOf(sorted[i])] = l;\n\n    // Clear moved flag, if it exists.\n    l.moved = false;\n  }\n\n  return out;\n}\n\nconst heightWidth = { x: \"w\", y: \"h\" };\n/**\n * Before moving item down, it will check if the movement will cause collisions and move those items down before.\n */\nfunction resolveCompactionCollision(\n  layout: Layout,\n  item: LayoutItem,\n  moveToCoord: number,\n  axis: \"x\" | \"y\"\n) {\n  const sizeProp = heightWidth[axis];\n  item[axis] += 1;\n  const itemIndex = layout\n    .map(layoutItem => {\n      return layoutItem.i;\n    })\n    .indexOf(item.i);\n\n  // Go through each item we collide with.\n  for (let i = itemIndex + 1; i < layout.length; i++) {\n    const otherItem = layout[i];\n    // Ignore static items\n    if (otherItem.static) continue;\n\n    // Optimization: we can break early if we know we're past this el\n    // We can do this b/c it's a sorted layout\n    if (otherItem.y > item.y + item.h) break;\n\n    if (collides(item, otherItem)) {\n      resolveCompactionCollision(\n        layout,\n        otherItem,\n        moveToCoord + item[sizeProp],\n        axis\n      );\n    }\n  }\n\n  item[axis] = moveToCoord;\n}\n\n/**\n * Compact an item in the layout.\n *\n * Modifies item.\n *\n */\nexport function compactItem(\n  compareWith: Layout,\n  l: LayoutItem,\n  compactType: CompactType,\n  cols: number,\n  fullLayout: Layout\n): LayoutItem {\n  const compactV = compactType === \"vertical\";\n  const compactH = compactType === \"horizontal\";\n  if (compactV) {\n    // Bottom 'y' possible is the bottom of the layout.\n    // This allows you to do nice stuff like specify {y: Infinity}\n    // This is here because the layout must be sorted in order to get the correct bottom `y`.\n    l.y = Math.min(bottom(compareWith), l.y);\n    // Move the element up as far as it can go without colliding.\n    while (l.y > 0 && !getFirstCollision(compareWith, l)) {\n      l.y--;\n    }\n  } else if (compactH) {\n    // Move the element left as far as it can go without colliding.\n    while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n      l.x--;\n    }\n  }\n\n  // Move it down, and keep moving it down if it's colliding.\n  let collides;\n  while ((collides = getFirstCollision(compareWith, l))) {\n    if (compactH) {\n      resolveCompactionCollision(fullLayout, l, collides.x + collides.w, \"x\");\n    } else {\n      resolveCompactionCollision(fullLayout, l, collides.y + collides.h, \"y\");\n    }\n    // Since we can't grow without bounds horizontally, if we've overflown, let's move it down and try again.\n    if (compactH && l.x + l.w > cols) {\n      l.x = cols - l.w;\n      l.y++;\n    }\n  }\n\n  // Ensure that there are no negative positions\n  l.y = Math.max(l.y, 0);\n  l.x = Math.max(l.x, 0);\n\n  return l;\n}\n\n/**\n * Given a layout, make sure all elements fit within its bounds.\n *\n * Modifies layout items.\n *\n * @param  {Array} layout Layout array.\n * @param  {Number} bounds Number of columns.\n */\nexport function correctBounds(\n  layout: Layout,\n  bounds: { cols: number }\n): Layout {\n  const collidesWith = getStatics(layout);\n  for (let i = 0, len = layout.length; i < len; i++) {\n    const l = layout[i];\n    // Overflows right\n    if (l.x + l.w > bounds.cols) l.x = bounds.cols - l.w;\n    // Overflows left\n    if (l.x < 0) {\n      l.x = 0;\n      l.w = bounds.cols;\n    }\n    if (!l.static) collidesWith.push(l);\n    else {\n      // If this is static and collides with other statics, we must move it down.\n      // We have to do something nicer than just letting them overlap.\n      while (getFirstCollision(collidesWith, l)) {\n        l.y++;\n      }\n    }\n  }\n  return layout;\n}\n\n/**\n * Get a layout item by ID. Used so we can override later on if necessary.\n *\n * @param  {Array}  layout Layout array.\n * @param  {String} id     ID\n * @return {LayoutItem}    Item at ID.\n */\nexport function getLayoutItem(layout: Layout, id: string): ?LayoutItem {\n  for (let i = 0, len = layout.length; i < len; i++) {\n    if (layout[i].i === id) return layout[i];\n  }\n}\n\n/**\n * Returns the first item this layout collides with.\n * It doesn't appear to matter which order we approach this from, although\n * perhaps that is the wrong thing to do.\n *\n * @param  {Object} layoutItem Layout item.\n * @return {Object|undefined}  A colliding layout item, or undefined.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem\n): ?LayoutItem {\n  for (let i = 0, len = layout.length; i < len; i++) {\n    if (collides(layout[i], layoutItem)) return layout[i];\n  }\n}\n\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem\n): Array<LayoutItem> {\n  return layout.filter(l => collides(l, layoutItem));\n}\n\n/**\n * Get all static elements.\n * @param  {Array} layout Array of layout objects.\n * @return {Array}        Array of static layout items..\n */\nexport function getStatics(layout: Layout): Array<LayoutItem> {\n  return layout.filter(l => l.static);\n}\n\n/**\n * Move an element. Responsible for doing cascading movements of other elements.\n *\n * Modifies layout items.\n *\n * @param  {Array}      layout            Full layout to modify.\n * @param  {LayoutItem} l                 element to move.\n * @param  {Number}     [x]               X position in grid units.\n * @param  {Number}     [y]               Y position in grid units.\n */\nexport function moveElement(\n  layout: Layout,\n  l: LayoutItem,\n  x: ?number,\n  y: ?number,\n  isUserAction: ?boolean,\n  preventCollision: ?boolean,\n  compactType: CompactType,\n  cols: number,\n  allowOverlap: ?boolean\n): Layout {\n  // If this is static and not explicitly enabled as draggable,\n  // no move is possible, so we can short-circuit this immediately.\n  if (l.static && l.isDraggable !== true) return layout;\n\n  // Short-circuit if nothing to do.\n  if (l.y === y && l.x === x) return layout;\n\n  log(\n    `Moving element ${l.i} to [${String(x)},${String(y)}] from [${l.x},${l.y}]`\n  );\n  const oldX = l.x;\n  const oldY = l.y;\n\n  // This is quite a bit faster than extending the object\n  if (typeof x === \"number\") l.x = x;\n  if (typeof y === \"number\") l.y = y;\n  l.moved = true;\n\n  // If this collides with anything, move it.\n  // When doing this comparison, we have to sort the items we compare with\n  // to ensure, in the case of multiple collisions, that we're getting the\n  // nearest collision.\n  let sorted = sortLayoutItems(layout, compactType);\n  const movingUp =\n    compactType === \"vertical\" && typeof y === \"number\"\n      ? oldY >= y\n      : compactType === \"horizontal\" && typeof x === \"number\"\n      ? oldX >= x\n      : false;\n  // $FlowIgnore acceptable modification of read-only array as it was recently cloned\n  if (movingUp) sorted = sorted.reverse();\n  const collisions = getAllCollisions(sorted, l);\n  const hasCollisions = collisions.length > 0;\n\n  // We may have collisions. We can short-circuit if we've turned off collisions or\n  // allowed overlap.\n  if (hasCollisions && allowOverlap) {\n    // Easy, we don't need to resolve collisions. But we *did* change the layout,\n    // so clone it on the way out.\n    return cloneLayout(layout);\n  } else if (hasCollisions && preventCollision) {\n    // If we are preventing collision but not allowing overlap, we need to\n    // revert the position of this element so it goes to where it came from, rather\n    // than the user's desired location.\n    log(`Collision prevented on ${l.i}, reverting.`);\n    l.x = oldX;\n    l.y = oldY;\n    l.moved = false;\n    return layout; // did not change so don't clone\n  }\n\n  // Move each item that collides away from this element.\n  for (let i = 0, len = collisions.length; i < len; i++) {\n    const collision = collisions[i];\n    log(\n      `Resolving collision between ${l.i} at [${l.x},${l.y}] and ${collision.i} at [${collision.x},${collision.y}]`\n    );\n\n    // Short circuit so we can't infinite loop\n    if (collision.moved) continue;\n\n    // Don't move static items - we have to move *this* element away\n    if (collision.static) {\n      layout = moveElementAwayFromCollision(\n        layout,\n        collision,\n        l,\n        isUserAction,\n        compactType,\n        cols\n      );\n    } else {\n      layout = moveElementAwayFromCollision(\n        layout,\n        l,\n        collision,\n        isUserAction,\n        compactType,\n        cols\n      );\n    }\n  }\n\n  return layout;\n}\n\n/**\n * This is where the magic needs to happen - given a collision, move an element away from the collision.\n * We attempt to move it up if there's room, otherwise it goes below.\n *\n * @param  {Array} layout            Full layout to modify.\n * @param  {LayoutItem} collidesWith Layout item we're colliding with.\n * @param  {LayoutItem} itemToMove   Layout item we're moving.\n */\nexport function moveElementAwayFromCollision(\n  layout: Layout,\n  collidesWith: LayoutItem,\n  itemToMove: LayoutItem,\n  isUserAction: ?boolean,\n  compactType: CompactType,\n  cols: number\n): Layout {\n  const compactH = compactType === \"horizontal\";\n  // Compact vertically if not set to horizontal\n  const compactV = compactType !== \"horizontal\";\n  const preventCollision = collidesWith.static; // we're already colliding (not for static items)\n\n  // If there is enough space above the collision to put this element, move it there.\n  // We only do this on the main collision as this can get funky in cascades and cause\n  // unwanted swapping behavior.\n  if (isUserAction) {\n    // Reset isUserAction flag because we're not in the main collision anymore.\n    isUserAction = false;\n\n    // Make a mock item so we don't modify the item here, only modify in moveElement.\n    const fakeItem: LayoutItem = {\n      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,\n      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,\n      w: itemToMove.w,\n      h: itemToMove.h,\n      i: \"-1\"\n    };\n\n    // No collision? If so, we can go up there; otherwise, we'll end up moving down as normal\n    if (!getFirstCollision(layout, fakeItem)) {\n      log(\n        `Doing reverse collision on ${itemToMove.i} up to [${fakeItem.x},${fakeItem.y}].`\n      );\n      return moveElement(\n        layout,\n        itemToMove,\n        compactH ? fakeItem.x : undefined,\n        compactV ? fakeItem.y : undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols\n      );\n    }\n  }\n\n  return moveElement(\n    layout,\n    itemToMove,\n    compactH ? itemToMove.x + 1 : undefined,\n    compactV ? itemToMove.y + 1 : undefined,\n    isUserAction,\n    preventCollision,\n    compactType,\n    cols\n  );\n}\n\n/**\n * Helper to convert a number to a percentage string.\n *\n * @param  {Number} num Any number\n * @return {String}     That number as a percentage.\n */\nexport function perc(num: number): string {\n  return num * 100 + \"%\";\n}\n\nexport function setTransform({ top, left, width, height }: Position): Object {\n  // Replace unitless items with px\n  const translate = `translate(${left}px,${top}px)`;\n  return {\n    transform: translate,\n    WebkitTransform: translate,\n    MozTransform: translate,\n    msTransform: translate,\n    OTransform: translate,\n    width: `${width}px`,\n    height: `${height}px`,\n    position: \"absolute\"\n  };\n}\n\nexport function setTopLeft({ top, left, width, height }: Position): Object {\n  return {\n    top: `${top}px`,\n    left: `${left}px`,\n    width: `${width}px`,\n    height: `${height}px`,\n    position: \"absolute\"\n  };\n}\n\n/**\n * Get layout items sorted from top left to right and down.\n *\n * @return {Array} Array of layout objects.\n * @return {Array}        Layout, sorted static items first.\n */\nexport function sortLayoutItems(\n  layout: Layout,\n  compactType: CompactType\n): Layout {\n  if (compactType === \"horizontal\") return sortLayoutItemsByColRow(layout);\n  if (compactType === \"vertical\") return sortLayoutItemsByRowCol(layout);\n  else return layout;\n}\n\n/**\n * Sort layout items by row ascending and column ascending.\n *\n * Does not modify Layout.\n */\nexport function sortLayoutItemsByRowCol(layout: Layout): Layout {\n  // Slice to clone array as sort modifies\n  return layout.slice(0).sort(function (a, b) {\n    if (a.y > b.y || (a.y === b.y && a.x > b.x)) {\n      return 1;\n    } else if (a.y === b.y && a.x === b.x) {\n      // Without this, we can get different sort results in IE vs. Chrome/FF\n      return 0;\n    }\n    return -1;\n  });\n}\n\n/**\n * Sort layout items by column ascending then row ascending.\n *\n * Does not modify Layout.\n */\nexport function sortLayoutItemsByColRow(layout: Layout): Layout {\n  return layout.slice(0).sort(function (a, b) {\n    if (a.x > b.x || (a.x === b.x && a.y > b.y)) {\n      return 1;\n    }\n    return -1;\n  });\n}\n\n/**\n * Generate a layout using the initialLayout and children as a template.\n * Missing entries will be added, extraneous ones will be truncated.\n *\n * Does not modify initialLayout.\n *\n * @param  {Array}  initialLayout Layout passed in through props.\n * @param  {String} breakpoint    Current responsive breakpoint.\n * @param  {?String} compact      Compaction option.\n * @return {Array}                Working layout.\n */\nexport function synchronizeLayoutWithChildren(\n  initialLayout: Layout,\n  children: ReactChildren,\n  cols: number,\n  compactType: CompactType,\n  allowOverlap: ?boolean\n): Layout {\n  initialLayout = initialLayout || [];\n\n  // Generate one layout item per child.\n  const layout: LayoutItem[] = [];\n  React.Children.forEach(children, (child: ReactElement<any>) => {\n    // Child may not exist\n    if (child?.key == null) return;\n\n    // Don't overwrite if it already exists.\n    const exists = getLayoutItem(initialLayout, String(child.key));\n    if (exists) {\n      layout.push(cloneLayoutItem(exists));\n    } else {\n      if (!isProduction && child.props._grid) {\n        console.warn(\n          \"`_grid` properties on children have been deprecated as of React 15.2. \" + // eslint-disable-line\n            \"Please use `data-grid` or add your properties directly to the `layout`.\"\n        );\n      }\n      const g = child.props[\"data-grid\"] || child.props._grid;\n\n      // Hey, this item has a data-grid property, use it.\n      if (g) {\n        if (!isProduction) {\n          validateLayout([g], \"ReactGridLayout.children\");\n        }\n        // FIXME clone not really necessary here\n        layout.push(cloneLayoutItem({ ...g, i: child.key }));\n      } else {\n        // Nothing provided: ensure this is added to the bottom\n        // FIXME clone not really necessary here\n        layout.push(\n          cloneLayoutItem({\n            w: 1,\n            h: 1,\n            x: 0,\n            y: bottom(layout),\n            i: String(child.key)\n          })\n        );\n      }\n    }\n  });\n\n  // Correct the layout.\n  const correctedLayout = correctBounds(layout, { cols: cols });\n  return allowOverlap\n    ? correctedLayout\n    : compact(correctedLayout, compactType, cols);\n}\n\n/**\n * Validate a layout. Throws errors.\n *\n * @param  {Array}  layout        Array of layout items.\n * @param  {String} [contextName] Context name for errors.\n * @throw  {Error}                Validation error.\n */\nexport function validateLayout(\n  layout: Layout,\n  contextName: string = \"Layout\"\n): void {\n  const subProps = [\"x\", \"y\", \"w\", \"h\"];\n  if (!Array.isArray(layout))\n    throw new Error(contextName + \" must be an array!\");\n  for (let i = 0, len = layout.length; i < len; i++) {\n    const item = layout[i];\n    for (let j = 0; j < subProps.length; j++) {\n      if (typeof item[subProps[j]] !== \"number\") {\n        throw new Error(\n          \"ReactGridLayout: \" +\n            contextName +\n            \"[\" +\n            i +\n            \"].\" +\n            subProps[j] +\n            \" must be a number!\"\n        );\n      }\n    }\n    if (item.i && typeof item.i !== \"string\") {\n      throw new Error(\n        \"ReactGridLayout: \" + contextName + \"[\" + i + \"].i must be a string!\"\n      );\n    }\n    if (item.static !== undefined && typeof item.static !== \"boolean\") {\n      throw new Error(\n        \"ReactGridLayout: \" +\n          contextName +\n          \"[\" +\n          i +\n          \"].static must be a boolean!\"\n      );\n    }\n  }\n}\n\n// Legacy support for verticalCompact: false\nexport function compactType(\n  props: ?{ verticalCompact: boolean, compactType: CompactType }\n): CompactType {\n  const { verticalCompact, compactType } = props || {};\n  return verticalCompact === false ? null : compactType;\n}\n\nfunction log(...args) {\n  if (!DEBUG) return;\n  // eslint-disable-next-line no-console\n  console.log(...args);\n}\n\nexport const noop = () => {};\n","function toVal(mix) {\n\tvar k, y, str='';\n\n\tif (typeof mix === 'string' || typeof mix === 'number') {\n\t\tstr += mix;\n\t} else if (typeof mix === 'object') {\n\t\tif (Array.isArray(mix)) {\n\t\t\tfor (k=0; k < mix.length; k++) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tif (y = toVal(mix[k])) {\n\t\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\t\tstr += y;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (k in mix) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\tstr += k;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn str;\n}\n\nexport default function () {\n\tvar i=0, tmp, x, str='';\n\twhile (i < arguments.length) {\n\t\tif (tmp = arguments[i++]) {\n\t\t\tif (x = toVal(tmp)) {\n\t\t\t\tstr && (str += ' ');\n\t\t\t\tstr += x\n\t\t\t}\n\t\t}\n\t}\n\treturn str;\n}\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = isEqual;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"DraggableCore\", {\n  enumerable: true,\n  get: function get() {\n    return _DraggableCore.default;\n  }\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _clsx2 = _interopRequireDefault(require(\"clsx\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _DraggableCore = _interopRequireDefault(require(\"./DraggableCore\"));\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nvar _excluded = [\"axis\", \"bounds\", \"children\", \"defaultPosition\", \"defaultClassName\", \"defaultClassNameDragging\", \"defaultClassNameDragged\", \"position\", \"positionOffset\", \"scale\"];\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _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; }\n\nfunction _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); }\n\nfunction _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; }\n\nfunction _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; }\n\nfunction ownKeys(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; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _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.\"); }\n\nfunction _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); }\n\nfunction _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; }\n\nfunction _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; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _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 } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _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); }; }\n\nfunction _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); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _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; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n//\n// Define <Draggable>\n//\nvar Draggable = /*#__PURE__*/function (_React$Component) {\n  _inherits(Draggable, _React$Component);\n\n  var _super = _createSuper(Draggable);\n\n  function Draggable(props\n  /*: DraggableProps*/\n  ) {\n    var _this;\n\n    _classCallCheck(this, Draggable);\n\n    _this = _super.call(this, props);\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStart\", function (e, coreData) {\n      (0, _log.default)('Draggable: onDragStart: %j', coreData); // Short-circuit if user's callback killed it.\n\n      var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData)); // Kills start event on core as well, so move handlers are never bound.\n\n\n      if (shouldStart === false) return false;\n\n      _this.setState({\n        dragging: true,\n        dragged: true\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDrag\", function (e, coreData) {\n      if (!_this.state.dragging) return false;\n      (0, _log.default)('Draggable: onDrag: %j', coreData);\n      var uiData = (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        x: uiData.x,\n        y: uiData.y\n      }; // Keep within bounds.\n\n      if (_this.props.bounds) {\n        // Save original x and y.\n        var x = newState.x,\n            y = newState.y; // Add slack to the values used to calculate bound position. This will ensure that if\n        // we start removing slack, the element won't react to it right away until it's been\n        // completely removed.\n\n        newState.x += _this.state.slackX;\n        newState.y += _this.state.slackY; // Get bound position. This will ceil/floor the x and y within the boundaries.\n\n        var _getBoundPosition = (0, _positionFns.getBoundPosition)(_assertThisInitialized(_this), newState.x, newState.y),\n            _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2),\n            newStateX = _getBoundPosition2[0],\n            newStateY = _getBoundPosition2[1];\n\n        newState.x = newStateX;\n        newState.y = newStateY; // Recalculate slack by noting how much was shaved by the boundPosition handler.\n\n        newState.slackX = _this.state.slackX + (x - newState.x);\n        newState.slackY = _this.state.slackY + (y - newState.y); // Update the event we fire to reflect what really happened after bounds took effect.\n\n        uiData.x = newState.x;\n        uiData.y = newState.y;\n        uiData.deltaX = newState.x - _this.state.x;\n        uiData.deltaY = newState.y - _this.state.y;\n      } // Short-circuit if user's callback killed it.\n\n\n      var shouldUpdate = _this.props.onDrag(e, uiData);\n\n      if (shouldUpdate === false) return false;\n\n      _this.setState(newState);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStop\", function (e, coreData) {\n      if (!_this.state.dragging) return false; // Short-circuit if user's callback killed it.\n\n      var shouldContinue = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData));\n\n      if (shouldContinue === false) return false;\n      (0, _log.default)('Draggable: onDragStop: %j', coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        dragging: false,\n        slackX: 0,\n        slackY: 0\n      }; // If this is a controlled component, the result of this operation will be to\n      // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n\n      var controlled = Boolean(_this.props.position);\n\n      if (controlled) {\n        var _this$props$position = _this.props.position,\n            x = _this$props$position.x,\n            y = _this$props$position.y;\n        newState.x = x;\n        newState.y = y;\n      }\n\n      _this.setState(newState);\n    });\n\n    _this.state = {\n      // Whether or not we are currently dragging.\n      dragging: false,\n      // Whether or not we have been dragged before.\n      dragged: false,\n      // Current transform x and y.\n      x: props.position ? props.position.x : props.defaultPosition.x,\n      y: props.position ? props.position.y : props.defaultPosition.y,\n      prevPropsPosition: _objectSpread({}, props.position),\n      // Used for compensating for out-of-bounds drags\n      slackX: 0,\n      slackY: 0,\n      // Can only determine if SVG after mounting\n      isElementSVG: false\n    };\n\n    if (props.position && !(props.onDrag || props.onStop)) {\n      // eslint-disable-next-line no-console\n      console.warn('A `position` was applied to this <Draggable>, without drag handlers. This will make this ' + 'component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the ' + '`position` of this element.');\n    }\n\n    return _this;\n  }\n\n  _createClass(Draggable, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      // Check to see if the element passed is an instanceof SVGElement\n      if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {\n        this.setState({\n          isElementSVG: true\n        });\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.setState({\n        dragging: false\n      }); // prevents invariant if unmounted while dragging\n    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n    // the underlying DOM node ourselves. See the README for more information.\n\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;\n\n      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render()\n    /*: ReactElement<any>*/\n    {\n      var _clsx;\n\n      var _this$props2 = this.props,\n          axis = _this$props2.axis,\n          bounds = _this$props2.bounds,\n          children = _this$props2.children,\n          defaultPosition = _this$props2.defaultPosition,\n          defaultClassName = _this$props2.defaultClassName,\n          defaultClassNameDragging = _this$props2.defaultClassNameDragging,\n          defaultClassNameDragged = _this$props2.defaultClassNameDragged,\n          position = _this$props2.position,\n          positionOffset = _this$props2.positionOffset,\n          scale = _this$props2.scale,\n          draggableCoreProps = _objectWithoutProperties(_this$props2, _excluded);\n\n      var style = {};\n      var svgTransform = null; // If this is controlled, we don't want to move it - unless it's dragging.\n\n      var controlled = Boolean(position);\n      var draggable = !controlled || this.state.dragging;\n      var validPosition = position || defaultPosition;\n      var transformOpts = {\n        // Set left if horizontal drag is enabled\n        x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,\n        // Set top if vertical drag is enabled\n        y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y\n      }; // If this element was SVG, we use the `transform` attribute.\n\n      if (this.state.isElementSVG) {\n        svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);\n      } else {\n        // Add a CSS transform to move the element around. This allows us to move the element around\n        // without worrying about whether or not it is relatively or absolutely positioned.\n        // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>\n        // has a clean slate.\n        style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);\n      } // Mark with class while dragging\n\n\n      var className = (0, _clsx2.default)(children.props.className || '', defaultClassName, (_clsx = {}, _defineProperty(_clsx, defaultClassNameDragging, this.state.dragging), _defineProperty(_clsx, defaultClassNameDragged, this.state.dragged), _clsx)); // Reuse the child provided\n      // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\n      return /*#__PURE__*/React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {\n        onStart: this.onDragStart,\n        onDrag: this.onDrag,\n        onStop: this.onDragStop\n      }), /*#__PURE__*/React.cloneElement(React.Children.only(children), {\n        className: className,\n        style: _objectSpread(_objectSpread({}, children.props.style), style),\n        transform: svgTransform\n      }));\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: // React 16.3+\n    // Arity (props, state)\n    function getDerivedStateFromProps(_ref, _ref2)\n    /*: ?$Shape<DraggableState>*/\n    {\n      var position = _ref.position;\n      var prevPropsPosition = _ref2.prevPropsPosition;\n\n      // Set x/y if a new position is provided in props that is different than the previous.\n      if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {\n        (0, _log.default)('Draggable: getDerivedStateFromProps %j', {\n          position: position,\n          prevPropsPosition: prevPropsPosition\n        });\n        return {\n          x: position.x,\n          y: position.y,\n          prevPropsPosition: _objectSpread({}, position)\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return Draggable;\n}(React.Component);\n\nexports.default = Draggable;\n\n_defineProperty(Draggable, \"displayName\", 'Draggable');\n\n_defineProperty(Draggable, \"propTypes\", _objectSpread(_objectSpread({}, _DraggableCore.default.propTypes), {}, {\n  /**\n   * `axis` determines which axis the draggable can move.\n   *\n   *  Note that all callbacks will still return data as normal. This only\n   *  controls flushing to the DOM.\n   *\n   * 'both' allows movement horizontally and vertically.\n   * 'x' limits movement to horizontal axis.\n   * 'y' limits movement to vertical axis.\n   * 'none' limits all movement.\n   *\n   * Defaults to 'both'.\n   */\n  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),\n\n  /**\n   * `bounds` determines the range of movement available to the element.\n   * Available values are:\n   *\n   * 'parent' restricts movement within the Draggable's parent node.\n   *\n   * Alternatively, pass an object with the following properties, all of which are optional:\n   *\n   * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n   *\n   * All values are in px.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable bounds={{right: 300, bottom: 300}}>\n   *              <div>Content</div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  bounds: _propTypes.default.oneOfType([_propTypes.default.shape({\n    left: _propTypes.default.number,\n    right: _propTypes.default.number,\n    top: _propTypes.default.number,\n    bottom: _propTypes.default.number\n  }), _propTypes.default.string, _propTypes.default.oneOf([false])]),\n  defaultClassName: _propTypes.default.string,\n  defaultClassNameDragging: _propTypes.default.string,\n  defaultClassNameDragged: _propTypes.default.string,\n\n  /**\n   * `defaultPosition` specifies the x and y that the dragged item should start at\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable defaultPosition={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  defaultPosition: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n  positionOffset: _propTypes.default.shape({\n    x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),\n    y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string])\n  }),\n\n  /**\n   * `position`, if present, defines the current position of the element.\n   *\n   *  This is similar to how form elements in React work - if no `position` is supplied, the component\n   *  is uncontrolled.\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable position={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  position: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n}));\n\n_defineProperty(Draggable, \"defaultProps\", _objectSpread(_objectSpread({}, _DraggableCore.default.defaultProps), {}, {\n  axis: 'both',\n  bounds: false,\n  defaultClassName: 'react-draggable',\n  defaultClassNameDragging: 'react-draggable-dragging',\n  defaultClassNameDragged: 'react-draggable-dragged',\n  defaultPosition: {\n    x: 0,\n    y: 0\n  },\n  scale: 1\n}));","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _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; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _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.\"); }\n\nfunction _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); }\n\nfunction _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; }\n\nfunction _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; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _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 } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _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); }; }\n\nfunction _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); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _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; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// Simple abstraction for dragging events names.\nvar eventsFor = {\n  touch: {\n    start: 'touchstart',\n    move: 'touchmove',\n    stop: 'touchend'\n  },\n  mouse: {\n    start: 'mousedown',\n    move: 'mousemove',\n    stop: 'mouseup'\n  }\n}; // Default to mouse events.\n\nvar dragEventFor = eventsFor.mouse;\n/*:: type DraggableCoreState = {\n  dragging: boolean,\n  lastX: number,\n  lastY: number,\n  touchIdentifier: ?number\n};*/\n\n/*:: export type DraggableData = {\n  node: HTMLElement,\n  x: number, y: number,\n  deltaX: number, deltaY: number,\n  lastX: number, lastY: number,\n};*/\n\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void | false;*/\n\n/*:: export type ControlPosition = {x: number, y: number};*/\n\n/*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/\n\n/*:: export type DraggableCoreDefaultProps = {\n  allowAnyClick: boolean,\n  disabled: boolean,\n  enableUserSelectHack: boolean,\n  onStart: DraggableEventHandler,\n  onDrag: DraggableEventHandler,\n  onStop: DraggableEventHandler,\n  onMouseDown: (e: MouseEvent) => void,\n  scale: number,\n};*/\n\n/*:: export type DraggableCoreProps = {\n  ...DraggableCoreDefaultProps,\n  cancel: string,\n  children: ReactElement<any>,\n  offsetParent: HTMLElement,\n  grid: [number, number],\n  handle: string,\n  nodeRef?: ?React.ElementRef<any>,\n};*/\n\n//\n// Define <DraggableCore>.\n//\n// <DraggableCore> is for advanced usage of <Draggable>. It maintains minimal internal state so it can\n// work well with libraries that require more control over the element.\n//\nvar DraggableCore = /*#__PURE__*/function (_React$Component) {\n  _inherits(DraggableCore, _React$Component);\n\n  var _super = _createSuper(DraggableCore);\n\n  function DraggableCore() {\n    var _this;\n\n    _classCallCheck(this, DraggableCore);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _super.call.apply(_super, [this].concat(args));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      dragging: false,\n      // Used while dragging to determine deltas.\n      lastX: NaN,\n      lastY: NaN,\n      touchIdentifier: null\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"mounted\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStart\", function (e) {\n      // Make it possible to attach event handlers on top of this one.\n      _this.props.onMouseDown(e); // Only accept left-clicks.\n\n\n      if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false; // Get nodes. Be sure to grab relative document (could be iframed)\n\n      var thisNode = _this.findDOMNode();\n\n      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n        throw new Error('<DraggableCore> not mounted on DragStart!');\n      }\n\n      var ownerDocument = thisNode.ownerDocument; // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\n      if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {\n        return;\n      } // Prevent scrolling on mobile devices, like ipad/iphone.\n      // Important that this is after handle/cancel.\n\n\n      if (e.type === 'touchstart') e.preventDefault(); // Set touch identifier in component state if this is a touch event. This allows us to\n      // distinguish between individual touches on multitouch screens by identifying which\n      // touchpoint was set to this element.\n\n      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n\n      _this.setState({\n        touchIdentifier: touchIdentifier\n      }); // Get the current drag point from the event. This is used as the offset.\n\n\n      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return; // not possible but satisfies flow\n\n      var x = position.x,\n          y = position.y; // Create an event object with all the data parents need to make a decision here.\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent); // Call event handler. If it returns explicit false, cancel.\n\n      (0, _log.default)('calling', _this.props.onStart);\n\n      var shouldUpdate = _this.props.onStart(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) return; // Add a style to the body to disable user-select. This prevents text from\n      // being selected all over the page.\n\n      if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument); // Initiate dragging. Set the current x and y as offsets\n      // so we know how much we've moved during the drag. This allows us\n      // to drag elements around even if they have been moved, without issue.\n\n      _this.setState({\n        dragging: true,\n        lastX: x,\n        lastY: y\n      }); // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n      // this element. We use different events depending on whether or not we have detected that this\n      // is a touch-capable device.\n\n\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDrag\", function (e) {\n      // Get the current drag point from the event. This is used as the offset.\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y; // Snap to grid if prop has been provided\n\n      if (Array.isArray(_this.props.grid)) {\n        var deltaX = x - _this.state.lastX,\n            deltaY = y - _this.state.lastY;\n\n        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);\n\n        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\n        deltaX = _snapToGrid2[0];\n        deltaY = _snapToGrid2[1];\n        if (!deltaX && !deltaY) return; // skip useless drag\n\n        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;\n      }\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent); // Call event handler. If it returns explicit false, trigger end.\n\n      var shouldUpdate = _this.props.onDrag(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) {\n        try {\n          // $FlowIgnore\n          _this.handleDragStop(new MouseEvent('mouseup'));\n        } catch (err) {\n          // Old browsers\n          var event = ((document.createEvent('MouseEvents')\n          /*: any*/\n          )\n          /*: MouseTouchEvent*/\n          ); // I see why this insanity was deprecated\n          // $FlowIgnore\n\n          event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n\n          _this.handleDragStop(event);\n        }\n\n        return;\n      }\n\n      _this.setState({\n        lastX: x,\n        lastY: y\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStop\", function (e) {\n      if (!_this.state.dragging) return;\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y;\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y); // Call event handler\n\n      var shouldContinue = _this.props.onStop(e, coreEvent);\n\n      if (shouldContinue === false || _this.mounted === false) return false;\n\n      var thisNode = _this.findDOMNode();\n\n      if (thisNode) {\n        // Remove user-select hack\n        if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n      }\n\n      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent); // Reset the el.\n\n      _this.setState({\n        dragging: false,\n        lastX: NaN,\n        lastY: NaN\n      });\n\n      if (thisNode) {\n        // Remove event handlers\n        (0, _log.default)('DraggableCore: Removing handlers');\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onMouseDown\", function (e) {\n      dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n      return _this.handleDragStart(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onMouseUp\", function (e) {\n      dragEventFor = eventsFor.mouse;\n      return _this.handleDragStop(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onTouchStart\", function (e) {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return _this.handleDragStart(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onTouchEnd\", function (e) {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return _this.handleDragStop(e);\n    });\n\n    return _this;\n  }\n\n  _createClass(DraggableCore, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.mounted = true; // Touch handlers must be added with {passive: false} to be cancelable.\n      // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n          passive: false\n        });\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.mounted = false; // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n      // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        var ownerDocument = thisNode.ownerDocument;\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n        (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n          passive: false\n        });\n        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);\n      }\n    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n    // the underlying DOM node ourselves. See the README for more information.\n\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;\n\n      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render()\n    /*: React.Element<any>*/\n    {\n      // Reuse the child provided\n      // This makes it flexible to use whatever element is wanted (div, ul, etc)\n      return /*#__PURE__*/React.cloneElement(React.Children.only(this.props.children), {\n        // Note: mouseMove handler is attached to document so it will still function\n        // when the user drags quickly and leaves the bounds of the element.\n        onMouseDown: this.onMouseDown,\n        onMouseUp: this.onMouseUp,\n        // onTouchStart is added on `componentDidMount` so they can be added with\n        // {passive: false}, which allows it to cancel. See\n        // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n        onTouchEnd: this.onTouchEnd\n      });\n    }\n  }]);\n\n  return DraggableCore;\n}(React.Component);\n\nexports.default = DraggableCore;\n\n_defineProperty(DraggableCore, \"displayName\", 'DraggableCore');\n\n_defineProperty(DraggableCore, \"propTypes\", {\n  /**\n   * `allowAnyClick` allows dragging using any mouse button.\n   * By default, we only accept the left button.\n   *\n   * Defaults to `false`.\n   */\n  allowAnyClick: _propTypes.default.bool,\n\n  /**\n   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,\n   * with the exception of `onMouseDown`, will not fire.\n   */\n  disabled: _propTypes.default.bool,\n\n  /**\n   * By default, we add 'user-select:none' attributes to the document body\n   * to prevent ugly text selection during drag. If this is causing problems\n   * for your app, set this to `false`.\n   */\n  enableUserSelectHack: _propTypes.default.bool,\n\n  /**\n   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n   * instead of using the parent node.\n   */\n  offsetParent: function offsetParent(props\n  /*: DraggableCoreProps*/\n  , propName\n  /*: $Keys<DraggableCoreProps>*/\n  ) {\n    if (props[propName] && props[propName].nodeType !== 1) {\n      throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n    }\n  },\n\n  /**\n   * `grid` specifies the x and y that dragging should snap to.\n   */\n  grid: _propTypes.default.arrayOf(_propTypes.default.number),\n\n  /**\n   * `handle` specifies a selector to be used as the handle that initiates drag.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable handle=\".handle\">\n   *              <div>\n   *                  <div className=\"handle\">Click me to drag</div>\n   *                  <div>This is some other content</div>\n   *              </div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  handle: _propTypes.default.string,\n\n  /**\n   * `cancel` specifies a selector to be used to prevent drag initialization.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *           return(\n   *               <Draggable cancel=\".cancel\">\n   *                   <div>\n   *                     <div className=\"cancel\">You can't drag from here</div>\n   *                     <div>Dragging here works fine</div>\n   *                   </div>\n   *               </Draggable>\n   *           );\n   *       }\n   *   });\n   * ```\n   */\n  cancel: _propTypes.default.string,\n\n  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.\n   * Unfortunately, in order for <Draggable> to work properly, we need raw access\n   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`\n   * as in this example:\n   *\n   * function MyComponent() {\n   *   const nodeRef = React.useRef(null);\n   *   return (\n   *     <Draggable nodeRef={nodeRef}>\n   *       <div ref={nodeRef}>Example Target</div>\n   *     </Draggable>\n   *   );\n   * }\n   *\n   * This can be used for arbitrarily nested components, so long as the ref ends up\n   * pointing to the actual child DOM node and not a custom component.\n   */\n  nodeRef: _propTypes.default.object,\n\n  /**\n   * Called when dragging starts.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onStart: _propTypes.default.func,\n\n  /**\n   * Called while dragging.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onDrag: _propTypes.default.func,\n\n  /**\n   * Called when dragging stops.\n   * If this function returns the boolean false, the drag will remain active.\n   */\n  onStop: _propTypes.default.func,\n\n  /**\n   * A workaround option which can be passed if onMouseDown needs to be accessed,\n   * since it'll always be blocked (as there is internal use of onMouseDown)\n   */\n  onMouseDown: _propTypes.default.func,\n\n  /**\n   * `scale`, if set, applies scaling while dragging an element\n   */\n  scale: _propTypes.default.number,\n\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n});\n\n_defineProperty(DraggableCore, \"defaultProps\", {\n  allowAnyClick: false,\n  // by default only accept left click\n  disabled: false,\n  enableUserSelectHack: true,\n  onStart: function onStart() {},\n  onDrag: function onDrag() {},\n  onStop: function onStop() {},\n  onMouseDown: function onMouseDown() {},\n  scale: 1\n});","\"use strict\";\n\nvar _require = require('./Draggable'),\n    Draggable = _require.default,\n    DraggableCore = _require.DraggableCore; // Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.\n// See https://github.com/mzabriskie/react-draggable/pull/254\n// and https://github.com/mzabriskie/react-draggable/issues/266\n\n\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = DraggableCore;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.addEvent = addEvent;\nexports.removeEvent = removeEvent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTranslation = getTranslation;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nexports.addClassName = addClassName;\nexports.removeClassName = removeClassName;\n\nvar _shims = require(\"./shims\");\n\nvar _getPrefix = _interopRequireWildcard(require(\"./getPrefix\"));\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _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; }\n\nfunction ownKeys(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; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar matchesSelectorFunc = '';\n\nfunction matchesSelector(el\n/*: Node*/\n, selector\n/*: string*/\n)\n/*: boolean*/\n{\n  if (!matchesSelectorFunc) {\n    matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n      // $FlowIgnore: Doesn't think elements are indexable\n      return (0, _shims.isFunction)(el[method]);\n    });\n  } // Might not be found entirely (not an Element?) - in that case, bail\n  // $FlowIgnore: Doesn't think elements are indexable\n\n\n  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable\n\n  return el[matchesSelectorFunc](selector);\n} // Works up the tree to the draggable itself attempting to match selector.\n\n\nfunction matchesSelectorAndParentsTo(el\n/*: Node*/\n, selector\n/*: string*/\n, baseNode\n/*: Node*/\n)\n/*: boolean*/\n{\n  var node = el;\n\n  do {\n    if (matchesSelector(node, selector)) return true;\n    if (node === baseNode) return false;\n    node = node.parentNode;\n  } while (node);\n\n  return false;\n}\n\nfunction addEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions); // $FlowIgnore[method-unbinding]\n\n\n  if (el.addEventListener) {\n    el.addEventListener(event, handler, options);\n  } else if (el.attachEvent) {\n    el.attachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = handler;\n  }\n}\n\nfunction removeEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions); // $FlowIgnore[method-unbinding]\n\n\n  if (el.removeEventListener) {\n    el.removeEventListener(event, handler, options);\n  } else if (el.detachEvent) {\n    el.detachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = null;\n  }\n}\n\nfunction outerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetTop which is including margin. See getBoundPosition\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height += (0, _shims.int)(computedStyle.borderTopWidth);\n  height += (0, _shims.int)(computedStyle.borderBottomWidth);\n  return height;\n}\n\nfunction outerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetLeft which is including margin. See getBoundPosition\n  var width = node.clientWidth;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width += (0, _shims.int)(computedStyle.borderLeftWidth);\n  width += (0, _shims.int)(computedStyle.borderRightWidth);\n  return width;\n}\n\nfunction innerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height -= (0, _shims.int)(computedStyle.paddingTop);\n  height -= (0, _shims.int)(computedStyle.paddingBottom);\n  return height;\n}\n\nfunction innerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var width = node.clientWidth;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width -= (0, _shims.int)(computedStyle.paddingLeft);\n  width -= (0, _shims.int)(computedStyle.paddingRight);\n  return width;\n}\n/*:: interface EventWithOffset {\n  clientX: number, clientY: number\n}*/\n\n\n// Get from offsetParent\nfunction offsetXYFromParent(evt\n/*: EventWithOffset*/\n, offsetParent\n/*: HTMLElement*/\n, scale\n/*: number*/\n)\n/*: ControlPosition*/\n{\n  var isBody = offsetParent === offsetParent.ownerDocument.body;\n  var offsetParentRect = isBody ? {\n    left: 0,\n    top: 0\n  } : offsetParent.getBoundingClientRect();\n  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;\n  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;\n  return {\n    x: x,\n    y: y\n  };\n}\n\nfunction createCSSTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: Object*/\n{\n  var translation = getTranslation(controlPos, positionOffset, 'px');\n  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default), translation);\n}\n\nfunction createSVGTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: string*/\n{\n  var translation = getTranslation(controlPos, positionOffset, '');\n  return translation;\n}\n\nfunction getTranslation(_ref2, positionOffset\n/*: PositionOffsetControlPosition*/\n, unitSuffix\n/*: string*/\n)\n/*: string*/\n{\n  var x = _ref2.x,\n      y = _ref2.y;\n  var translation = \"translate(\".concat(x).concat(unitSuffix, \",\").concat(y).concat(unitSuffix, \")\");\n\n  if (positionOffset) {\n    var defaultX = \"\".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);\n    var defaultY = \"\".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);\n    translation = \"translate(\".concat(defaultX, \", \").concat(defaultY, \")\") + translation;\n  }\n\n  return translation;\n}\n\nfunction getTouch(e\n/*: MouseTouchEvent*/\n, identifier\n/*: number*/\n)\n/*: ?{clientX: number, clientY: number}*/\n{\n  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n    return identifier === t.identifier;\n  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n    return identifier === t.identifier;\n  });\n}\n\nfunction getTouchIdentifier(e\n/*: MouseTouchEvent*/\n)\n/*: ?number*/\n{\n  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n} // User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n// Note we're passing `document` b/c we could be iframed\n\n\nfunction addUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n  var styleEl = doc.getElementById('react-draggable-style-el');\n\n  if (!styleEl) {\n    styleEl = doc.createElement('style');\n    styleEl.type = 'text/css';\n    styleEl.id = 'react-draggable-style-el';\n    styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {all: inherit;}\\n';\n    styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\\n';\n    doc.getElementsByTagName('head')[0].appendChild(styleEl);\n  }\n\n  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\n\nfunction removeUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n\n  try {\n    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE\n\n    if (doc.selection) {\n      // $FlowIgnore: IE\n      doc.selection.empty();\n    } else {\n      // Remove selection caused by scroll, unless it's a focused input\n      // (we use doc.defaultView in case we're in an iframe)\n      var selection = (doc.defaultView || window).getSelection();\n\n      if (selection && selection.type !== 'Caret') {\n        selection.removeAllRanges();\n      }\n    }\n  } catch (e) {// probably IE\n  }\n}\n\nfunction addClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\n  if (el.classList) {\n    el.classList.add(className);\n  } else {\n    if (!el.className.match(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\")))) {\n      el.className += \" \".concat(className);\n    }\n  }\n}\n\nfunction removeClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\n  if (el.classList) {\n    el.classList.remove(className);\n  } else {\n    el.className = el.className.replace(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\"), 'g'), '');\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getPrefix = getPrefix;\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nexports.default = void 0;\nvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\n\nfunction getPrefix()\n/*: string*/\n{\n  var _window$document, _window$document$docu;\n\n  var prop\n  /*: string*/\n  = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n  // Ensure we're running in an environment where there is actually a global\n  // `window` obj\n  if (typeof window === 'undefined') return ''; // If we're in a pseudo-browser server-side environment, this access\n  // path may not exist, so bail out if it doesn't.\n\n  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;\n  if (!style) return '';\n  if (prop in style) return '';\n\n  for (var i = 0; i < prefixes.length; i++) {\n    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n  }\n\n  return '';\n}\n\nfunction browserPrefixToKey(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"\".concat(prefix).concat(kebabToTitleCase(prop)) : prop;\n}\n\nfunction browserPrefixToStyle(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"-\".concat(prefix.toLowerCase(), \"-\").concat(prop) : prop;\n}\n\nfunction kebabToTitleCase(str\n/*: string*/\n)\n/*: string*/\n{\n  var out = '';\n  var shouldCapitalize = true;\n\n  for (var i = 0; i < str.length; i++) {\n    if (shouldCapitalize) {\n      out += str[i].toUpperCase();\n      shouldCapitalize = false;\n    } else if (str[i] === '-') {\n      shouldCapitalize = true;\n    } else {\n      out += str[i];\n    }\n  }\n\n  return out;\n} // Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\n\n\nvar _default = (getPrefix()\n/*: string*/\n);\n\nexports.default = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = log;\n\n/*eslint no-console:0*/\nfunction log() {\n  var _console;\n\n  if (undefined) (_console = console).log.apply(_console, arguments);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getBoundPosition = getBoundPosition;\nexports.snapToGrid = snapToGrid;\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.getControlPosition = getControlPosition;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\n\nvar _shims = require(\"./shims\");\n\nvar _domFns = require(\"./domFns\");\n\nfunction getBoundPosition(draggable\n/*: Draggable*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: [number, number]*/\n{\n  // If no bounds, short-circuit and move on\n  if (!draggable.props.bounds) return [x, y]; // Clone new bounds\n\n  var bounds = draggable.props.bounds;\n  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n  var node = findDOMNode(draggable);\n\n  if (typeof bounds === 'string') {\n    var ownerDocument = node.ownerDocument;\n    var ownerWindow = ownerDocument.defaultView;\n    var boundNode;\n\n    if (bounds === 'parent') {\n      boundNode = node.parentNode;\n    } else {\n      boundNode = ownerDocument.querySelector(bounds);\n    }\n\n    if (!(boundNode instanceof ownerWindow.HTMLElement)) {\n      throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n    }\n\n    var boundNodeEl\n    /*: HTMLElement*/\n    = boundNode; // for Flow, can't seem to refine correctly\n\n    var nodeStyle = ownerWindow.getComputedStyle(node);\n    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n\n    bounds = {\n      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),\n      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),\n      right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),\n      bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)\n    };\n  } // Keep x and y below right and bottom limits...\n\n\n  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom); // But above left and top limits.\n\n  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n  return [x, y];\n}\n\nfunction snapToGrid(grid\n/*: [number, number]*/\n, pendingX\n/*: number*/\n, pendingY\n/*: number*/\n)\n/*: [number, number]*/\n{\n  var x = Math.round(pendingX / grid[0]) * grid[0];\n  var y = Math.round(pendingY / grid[1]) * grid[1];\n  return [x, y];\n}\n\nfunction canDragX(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nfunction canDragY(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n} // Get {x, y} positions from event.\n\n\nfunction getControlPosition(e\n/*: MouseTouchEvent*/\n, touchIdentifier\n/*: ?number*/\n, draggableCore\n/*: DraggableCore*/\n)\n/*: ?ControlPosition*/\n{\n  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n\n  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.\n\n  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);\n} // Create an data object exposed by <DraggableCore>'s events\n\n\nfunction createCoreData(draggable\n/*: DraggableCore*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: DraggableData*/\n{\n  var state = draggable.state;\n  var isStart = !(0, _shims.isNum)(state.lastX);\n  var node = findDOMNode(draggable);\n\n  if (isStart) {\n    // If this is our first move, use the x and y as last coords.\n    return {\n      node: node,\n      deltaX: 0,\n      deltaY: 0,\n      lastX: x,\n      lastY: y,\n      x: x,\n      y: y\n    };\n  } else {\n    // Otherwise calculate proper values.\n    return {\n      node: node,\n      deltaX: x - state.lastX,\n      deltaY: y - state.lastY,\n      lastX: state.lastX,\n      lastY: state.lastY,\n      x: x,\n      y: y\n    };\n  }\n} // Create an data exposed by <Draggable>'s events\n\n\nfunction createDraggableData(draggable\n/*: Draggable*/\n, coreData\n/*: DraggableData*/\n)\n/*: DraggableData*/\n{\n  var scale = draggable.props.scale;\n  return {\n    node: coreData.node,\n    x: draggable.state.x + coreData.deltaX / scale,\n    y: draggable.state.y + coreData.deltaY / scale,\n    deltaX: coreData.deltaX / scale,\n    deltaY: coreData.deltaY / scale,\n    lastX: draggable.state.x,\n    lastY: draggable.state.y\n  };\n} // A lot faster than stringify/parse\n\n\nfunction cloneBounds(bounds\n/*: Bounds*/\n)\n/*: Bounds*/\n{\n  return {\n    left: bounds.left,\n    top: bounds.top,\n    right: bounds.right,\n    bottom: bounds.bottom\n  };\n}\n\nfunction findDOMNode(draggable\n/*: Draggable | DraggableCore*/\n)\n/*: HTMLElement*/\n{\n  var node = draggable.findDOMNode();\n\n  if (!node) {\n    throw new Error('<DraggableCore>: Unmounted during event!');\n  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n\n\n  return node;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.findInArray = findInArray;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\nexports.int = int;\nexports.dontSetMe = dontSetMe;\n\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array\n/*: Array<any> | TouchList*/\n, callback\n/*: Function*/\n)\n/*: any*/\n{\n  for (var i = 0, length = array.length; i < length; i++) {\n    if (callback.apply(callback, [array[i], i, array])) return array[i];\n  }\n}\n\nfunction isFunction(func\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  // $FlowIgnore[method-unbinding]\n  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nfunction isNum(num\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  return typeof num === 'number' && !isNaN(num);\n}\n\nfunction int(a\n/*: string*/\n)\n/*: number*/\n{\n  return parseInt(a, 10);\n}\n\nfunction dontSetMe(props\n/*: Object*/\n, propName\n/*: string*/\n, componentName\n/*: string*/\n)\n/*: ?Error*/\n{\n  if (props[propName]) {\n    return new Error(\"Invalid prop \".concat(propName, \" passed to \").concat(componentName, \" - do not set this, set it on the child.\"));\n  }\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _reactDraggable = require(\"react-draggable\");\n\nvar _utils = require(\"./utils\");\n\nvar _propTypes = require(\"./propTypes\");\n\nvar _excluded = [\"children\", \"className\", \"draggableOpts\", \"width\", \"height\", \"handle\", \"handleSize\", \"lockAspectRatio\", \"axis\", \"minConstraints\", \"maxConstraints\", \"onResize\", \"onResizeStop\", \"onResizeStart\", \"resizeHandles\", \"transformScale\"];\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _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; }\n\nfunction _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); }\n\nfunction _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; }\n\nfunction ownKeys(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; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\n// The base <Resizable> component.\n// This component does not have state and relies on the parent to set its props based on callback data.\nvar Resizable = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Resizable, _React$Component);\n\n  function Resizable() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.handleRefs = {};\n    _this.lastHandleRect = null;\n    _this.slack = null;\n    return _this;\n  }\n\n  var _proto = Resizable.prototype;\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.resetData();\n  };\n\n  _proto.resetData = function resetData() {\n    this.lastHandleRect = this.slack = null;\n  } // Clamp width and height within provided constraints\n  ;\n\n  _proto.runConstraints = function runConstraints(width, height) {\n    var _this$props = this.props,\n        minConstraints = _this$props.minConstraints,\n        maxConstraints = _this$props.maxConstraints,\n        lockAspectRatio = _this$props.lockAspectRatio; // short circuit\n\n    if (!minConstraints && !maxConstraints && !lockAspectRatio) return [width, height]; // If constraining to min and max, we need to also fit width and height to aspect ratio.\n\n    if (lockAspectRatio) {\n      var ratio = this.props.width / this.props.height;\n      var deltaW = width - this.props.width;\n      var deltaH = height - this.props.height; // Find which coordinate was greater and should push the other toward it.\n      // E.g.:\n      // ratio = 1, deltaW = 10, deltaH = 5, deltaH should become 10.\n      // ratio = 2, deltaW = 10, deltaH = 6, deltaW should become 12.\n\n      if (Math.abs(deltaW) > Math.abs(deltaH * ratio)) {\n        height = width / ratio;\n      } else {\n        width = height * ratio;\n      }\n    }\n\n    var oldW = width,\n        oldH = height; // Add slack to the values used to calculate bound position. This will ensure that if\n    // we start removing slack, the element won't react to it right away until it's been\n    // completely removed.\n\n    var _ref = this.slack || [0, 0],\n        slackW = _ref[0],\n        slackH = _ref[1];\n\n    width += slackW;\n    height += slackH;\n\n    if (minConstraints) {\n      width = Math.max(minConstraints[0], width);\n      height = Math.max(minConstraints[1], height);\n    }\n\n    if (maxConstraints) {\n      width = Math.min(maxConstraints[0], width);\n      height = Math.min(maxConstraints[1], height);\n    } // If the width or height changed, we must have introduced some slack. Record it for the next iteration.\n\n\n    this.slack = [slackW + (oldW - width), slackH + (oldH - height)];\n    return [width, height];\n  }\n  /**\n   * Wrapper around drag events to provide more useful data.\n   *\n   * @param  {String} handlerName Handler name to wrap.\n   * @return {Function}           Handler function.\n   */\n  ;\n\n  _proto.resizeHandler = function resizeHandler(handlerName, axis) {\n    var _this2 = this;\n\n    return function (e, _ref2) {\n      var node = _ref2.node,\n          deltaX = _ref2.deltaX,\n          deltaY = _ref2.deltaY;\n      // Reset data in case it was left over somehow (should not be possible)\n      if (handlerName === 'onResizeStart') _this2.resetData(); // Axis restrictions\n\n      var canDragX = (_this2.props.axis === 'both' || _this2.props.axis === 'x') && axis !== 'n' && axis !== 's';\n      var canDragY = (_this2.props.axis === 'both' || _this2.props.axis === 'y') && axis !== 'e' && axis !== 'w'; // No dragging possible.\n\n      if (!canDragX && !canDragY) return; // Decompose axis for later use\n\n      var axisV = axis[0];\n      var axisH = axis[axis.length - 1]; // intentionally not axis[1], so that this catches axis === 'w' for example\n      // Track the element being dragged to account for changes in position.\n      // If a handle's position is changed between callbacks, we need to factor this in to the next callback.\n      // Failure to do so will cause the element to \"skip\" when resized upwards or leftwards.\n\n      var handleRect = node.getBoundingClientRect();\n\n      if (_this2.lastHandleRect != null) {\n        // If the handle has repositioned on either axis since last render,\n        // we need to increase our callback values by this much.\n        // Only checking 'n', 'w' since resizing by 's', 'w' won't affect the overall position on page,\n        if (axisH === 'w') {\n          var deltaLeftSinceLast = handleRect.left - _this2.lastHandleRect.left;\n          deltaX += deltaLeftSinceLast;\n        }\n\n        if (axisV === 'n') {\n          var deltaTopSinceLast = handleRect.top - _this2.lastHandleRect.top;\n          deltaY += deltaTopSinceLast;\n        }\n      } // Storage of last rect so we know how much it has really moved.\n\n\n      _this2.lastHandleRect = handleRect; // Reverse delta if using top or left drag handles.\n\n      if (axisH === 'w') deltaX = -deltaX;\n      if (axisV === 'n') deltaY = -deltaY; // Update w/h by the deltas. Also factor in transformScale.\n\n      var width = _this2.props.width + (canDragX ? deltaX / _this2.props.transformScale : 0);\n      var height = _this2.props.height + (canDragY ? deltaY / _this2.props.transformScale : 0); // Run user-provided constraints.\n\n      var _this2$runConstraints = _this2.runConstraints(width, height);\n\n      width = _this2$runConstraints[0];\n      height = _this2$runConstraints[1];\n      var dimensionsChanged = width !== _this2.props.width || height !== _this2.props.height; // Call user-supplied callback if present.\n\n      var cb = typeof _this2.props[handlerName] === 'function' ? _this2.props[handlerName] : null; // Don't call 'onResize' if dimensions haven't changed.\n\n      var shouldSkipCb = handlerName === 'onResize' && !dimensionsChanged;\n\n      if (cb && !shouldSkipCb) {\n        e.persist == null ? void 0 : e.persist();\n        cb(e, {\n          node: node,\n          size: {\n            width: width,\n            height: height\n          },\n          handle: axis\n        });\n      } // Reset internal data\n\n\n      if (handlerName === 'onResizeStop') _this2.resetData();\n    };\n  } // Render a resize handle given an axis & DOM ref. Ref *must* be attached for\n  // the underlying draggable library to work properly.\n  ;\n\n  _proto.renderResizeHandle = function renderResizeHandle(handleAxis, ref) {\n    var handle = this.props.handle; // No handle provided, make the default\n\n    if (!handle) {\n      return /*#__PURE__*/React.createElement(\"span\", {\n        className: \"react-resizable-handle react-resizable-handle-\" + handleAxis,\n        ref: ref\n      });\n    } // Handle is a function, such as:\n    // `handle={(handleAxis) => <span className={...} />}`\n\n\n    if (typeof handle === 'function') {\n      return handle(handleAxis, ref);\n    } // Handle is a React component (composite or DOM).\n\n\n    var isDOMElement = typeof handle.type === 'string';\n\n    var props = _objectSpread({\n      ref: ref\n    }, isDOMElement ? {} : {\n      handleAxis: handleAxis\n    });\n\n    return /*#__PURE__*/React.cloneElement(handle, props);\n  };\n\n  _proto.render = function render() {\n    var _this3 = this;\n\n    // Pass along only props not meant for the `<Resizable>`.`\n    // eslint-disable-next-line no-unused-vars\n    var _this$props2 = this.props,\n        children = _this$props2.children,\n        className = _this$props2.className,\n        draggableOpts = _this$props2.draggableOpts,\n        width = _this$props2.width,\n        height = _this$props2.height,\n        handle = _this$props2.handle,\n        handleSize = _this$props2.handleSize,\n        lockAspectRatio = _this$props2.lockAspectRatio,\n        axis = _this$props2.axis,\n        minConstraints = _this$props2.minConstraints,\n        maxConstraints = _this$props2.maxConstraints,\n        onResize = _this$props2.onResize,\n        onResizeStop = _this$props2.onResizeStop,\n        onResizeStart = _this$props2.onResizeStart,\n        resizeHandles = _this$props2.resizeHandles,\n        transformScale = _this$props2.transformScale,\n        p = _objectWithoutPropertiesLoose(_this$props2, _excluded); // What we're doing here is getting the child of this element, and cloning it with this element's props.\n    // We are then defining its children as:\n    // 1. Its original children (resizable's child's children), and\n    // 2. One or more draggable handles.\n\n\n    return (0, _utils.cloneElement)(children, _objectSpread(_objectSpread({}, p), {}, {\n      className: (className ? className + \" \" : '') + \"react-resizable\",\n      children: [].concat(children.props.children, resizeHandles.map(function (handleAxis) {\n        var _this3$handleRefs$han;\n\n        // Create a ref to the handle so that `<DraggableCore>` doesn't have to use ReactDOM.findDOMNode().\n        var ref = (_this3$handleRefs$han = _this3.handleRefs[handleAxis]) != null ? _this3$handleRefs$han : _this3.handleRefs[handleAxis] = /*#__PURE__*/React.createRef();\n        return /*#__PURE__*/React.createElement(_reactDraggable.DraggableCore, _extends({}, draggableOpts, {\n          nodeRef: ref,\n          key: \"resizableHandle-\" + handleAxis,\n          onStop: _this3.resizeHandler('onResizeStop', handleAxis),\n          onStart: _this3.resizeHandler('onResizeStart', handleAxis),\n          onDrag: _this3.resizeHandler('onResize', handleAxis)\n        }), _this3.renderResizeHandle(handleAxis, ref));\n      }))\n    }));\n  };\n\n  return Resizable;\n}(React.Component);\n\nexports.default = Resizable;\nResizable.propTypes = _propTypes.resizableProps;\nResizable.defaultProps = {\n  axis: 'both',\n  handleSize: [20, 20],\n  lockAspectRatio: false,\n  minConstraints: [20, 20],\n  maxConstraints: [Infinity, Infinity],\n  resizeHandles: ['se'],\n  transformScale: 1\n};","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _Resizable = _interopRequireDefault(require(\"./Resizable\"));\n\nvar _propTypes2 = require(\"./propTypes\");\n\nvar _excluded = [\"handle\", \"handleSize\", \"onResize\", \"onResizeStart\", \"onResizeStop\", \"draggableOpts\", \"minConstraints\", \"maxConstraints\", \"lockAspectRatio\", \"axis\", \"width\", \"height\", \"resizeHandles\", \"style\", \"transformScale\"];\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _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; }\n\nfunction _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); }\n\nfunction ownKeys(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; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _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; }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nvar ResizableBox = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(ResizableBox, _React$Component);\n\n  function ResizableBox() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.state = {\n      width: _this.props.width,\n      height: _this.props.height,\n      propsWidth: _this.props.width,\n      propsHeight: _this.props.height\n    };\n\n    _this.onResize = function (e, data) {\n      var size = data.size;\n\n      if (_this.props.onResize) {\n        e.persist == null ? void 0 : e.persist();\n\n        _this.setState(size, function () {\n          return _this.props.onResize && _this.props.onResize(e, data);\n        });\n      } else {\n        _this.setState(size);\n      }\n    };\n\n    return _this;\n  }\n\n  ResizableBox.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {\n    // If parent changes height/width, set that in our state.\n    if (state.propsWidth !== props.width || state.propsHeight !== props.height) {\n      return {\n        width: props.width,\n        height: props.height,\n        propsWidth: props.width,\n        propsHeight: props.height\n      };\n    }\n\n    return null;\n  };\n\n  var _proto = ResizableBox.prototype;\n\n  _proto.render = function render() {\n    // Basic wrapper around a Resizable instance.\n    // If you use Resizable directly, you are responsible for updating the child component\n    // with a new width and height.\n    var _this$props = this.props,\n        handle = _this$props.handle,\n        handleSize = _this$props.handleSize,\n        onResize = _this$props.onResize,\n        onResizeStart = _this$props.onResizeStart,\n        onResizeStop = _this$props.onResizeStop,\n        draggableOpts = _this$props.draggableOpts,\n        minConstraints = _this$props.minConstraints,\n        maxConstraints = _this$props.maxConstraints,\n        lockAspectRatio = _this$props.lockAspectRatio,\n        axis = _this$props.axis,\n        width = _this$props.width,\n        height = _this$props.height,\n        resizeHandles = _this$props.resizeHandles,\n        style = _this$props.style,\n        transformScale = _this$props.transformScale,\n        props = _objectWithoutPropertiesLoose(_this$props, _excluded);\n\n    return /*#__PURE__*/React.createElement(_Resizable.default, {\n      axis: axis,\n      draggableOpts: draggableOpts,\n      handle: handle,\n      handleSize: handleSize,\n      height: this.state.height,\n      lockAspectRatio: lockAspectRatio,\n      maxConstraints: maxConstraints,\n      minConstraints: minConstraints,\n      onResizeStart: onResizeStart,\n      onResize: this.onResize,\n      onResizeStop: onResizeStop,\n      resizeHandles: resizeHandles,\n      transformScale: transformScale,\n      width: this.state.width\n    }, /*#__PURE__*/React.createElement(\"div\", _extends({}, props, {\n      style: _objectSpread(_objectSpread({}, style), {}, {\n        width: this.state.width + 'px',\n        height: this.state.height + 'px'\n      })\n    })));\n  };\n\n  return ResizableBox;\n}(React.Component);\n\nexports.default = ResizableBox;\nResizableBox.propTypes = _objectSpread(_objectSpread({}, _propTypes2.resizableProps), {}, {\n  children: _propTypes.default.element\n});","\"use strict\";\n\nexports.__esModule = true;\nexports.resizableProps = void 0;\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDraggable = require(\"react-draggable\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar resizableProps = {\n  /*\n  * Restricts resizing to a particular axis (default: 'both')\n  * 'both' - allows resizing by width or height\n  * 'x' - only allows the width to be changed\n  * 'y' - only allows the height to be changed\n  * 'none' - disables resizing altogether\n  * */\n  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),\n  className: _propTypes.default.string,\n\n  /*\n  * Require that one and only one child be present.\n  * */\n  children: _propTypes.default.element.isRequired,\n\n  /*\n  * These will be passed wholesale to react-draggable's DraggableCore\n  * */\n  draggableOpts: _propTypes.default.shape({\n    allowAnyClick: _propTypes.default.bool,\n    cancel: _propTypes.default.string,\n    children: _propTypes.default.node,\n    disabled: _propTypes.default.bool,\n    enableUserSelectHack: _propTypes.default.bool,\n    offsetParent: _propTypes.default.node,\n    grid: _propTypes.default.arrayOf(_propTypes.default.number),\n    handle: _propTypes.default.string,\n    nodeRef: _propTypes.default.object,\n    onStart: _propTypes.default.func,\n    onDrag: _propTypes.default.func,\n    onStop: _propTypes.default.func,\n    onMouseDown: _propTypes.default.func,\n    scale: _propTypes.default.number\n  }),\n\n  /*\n  * Initial height\n  * */\n  height: _propTypes.default.number.isRequired,\n\n  /*\n  * Customize cursor resize handle\n  * */\n  handle: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),\n\n  /*\n  * If you change this, be sure to update your css\n  * */\n  handleSize: _propTypes.default.arrayOf(_propTypes.default.number),\n  lockAspectRatio: _propTypes.default.bool,\n\n  /*\n  * Max X & Y measure\n  * */\n  maxConstraints: _propTypes.default.arrayOf(_propTypes.default.number),\n\n  /*\n  * Min X & Y measure\n  * */\n  minConstraints: _propTypes.default.arrayOf(_propTypes.default.number),\n\n  /*\n  * Called on stop resize event\n  * */\n  onResizeStop: _propTypes.default.func,\n\n  /*\n  * Called on start resize event\n  * */\n  onResizeStart: _propTypes.default.func,\n\n  /*\n  * Called on resize event\n  * */\n  onResize: _propTypes.default.func,\n\n  /*\n  * Defines which resize handles should be rendered (default: 'se')\n  * 's' - South handle (bottom-center)\n  * 'w' - West handle (left-center)\n  * 'e' - East handle (right-center)\n  * 'n' - North handle (top-center)\n  * 'sw' - Southwest handle (bottom-left)\n  * 'nw' - Northwest handle (top-left)\n  * 'se' - Southeast handle (bottom-right)\n  * 'ne' - Northeast handle (top-center)\n  * */\n  resizeHandles: _propTypes.default.arrayOf(_propTypes.default.oneOf(['s', 'w', 'e', 'n', 'sw', 'nw', 'se', 'ne'])),\n\n  /*\n  * If `transform: scale(n)` is set on the parent, this should be set to `n`.\n  * */\n  transformScale: _propTypes.default.number,\n\n  /*\n   * Initial width\n   */\n  width: _propTypes.default.number.isRequired\n};\nexports.resizableProps = resizableProps;","\"use strict\";\n\nexports.__esModule = true;\nexports.cloneElement = cloneElement;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction ownKeys(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; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// React.addons.cloneWithProps look-alike that merges style & className.\nfunction cloneElement(element, props) {\n  if (props.style && element.props.style) {\n    props.style = _objectSpread(_objectSpread({}, element.props.style), props.style);\n  }\n\n  if (props.className && element.props.className) {\n    props.className = element.props.className + \" \" + props.className;\n  }\n\n  return /*#__PURE__*/_react.default.cloneElement(element, props);\n}","'use strict';\nmodule.exports = function() {\n  throw new Error(\"Don't instantiate Resizable directly! Use require('react-resizable').Resizable\");\n};\n\nmodule.exports.Resizable = require('./build/Resizable').default;\nmodule.exports.ResizableBox = require('./build/ResizableBox').default;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__888__;","module.exports = __WEBPACK_EXTERNAL_MODULE__757__;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = function(module) {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","// startup\n// Load entry module and return exports\n// This entry module used 'module' so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(325);\n"],"names":["root","factory","exports","module","require","define","amd","self","__WEBPACK_EXTERNAL_MODULE__888__","__WEBPACK_EXTERNAL_MODULE__757__","utils","Responsive","WidthProvider","calcGridColWidth","positionParams","margin","containerPadding","containerWidth","cols","calcGridItemWHPx","gridUnits","colOrRowSize","marginPx","Number","isFinite","Math","round","max","calcGridItemPosition","x","y","w","h","state","rowHeight","colWidth","out","resizing","width","height","dragging","top","left","calcXY","maxRows","clamp","num","lowerBound","upperBound","min","resizeHandleAxesType","PropTypes","resizeHandleType","className","style","autoSize","draggableCancel","draggableHandle","verticalCompact","props","compactType","layout","undefined","isBounded","isDraggable","isResizable","allowOverlap","preventCollision","useCSSTransforms","transformScale","isDroppable","resizeHandles","resizeHandle","onLayoutChange","onDragStart","onDrag","onDragStop","onResizeStart","onResize","onResizeStop","onDrop","droppingItem","i","children","propName","keys","React","child","key","Error","innerRef","GridItem","e","node","newPosition","offsetParent","parentRect","getBoundingClientRect","clientRect","cLeft","pLeft","cTop","pTop","scrollLeft","scrollTop","setState","getPositionParams","call","deltaX","deltaY","clientHeight","callbackData","onResizeHandler","nextProps","nextState","this","droppingPosition","oldPosition","fastPositionEqual","moveDroppingItem","prevProps","elementRef","current","prevDroppingPosition","shouldDrag","pos","usePercentages","setTransform","setTopLeft","perc","DraggableCore","disabled","onStart","onStop","handle","cancel","scale","nodeRef","position","minW","minH","maxW","maxH","maxWidth","mins","maxes","minConstraints","maxConstraints","Infinity","Resizable","draggableOpts","handlerName","size","handler","calcWH","newChild","ref","clsx","static","Boolean","dropping","cssTransforms","createStyle","mixinResizable","mixinDraggable","value","layoutClassName","isFirefox","test","navigator","userAgent","ReactGridLayout","activeDrag","synchronizeLayoutWithChildren","mounted","oldDragItem","oldLayout","oldResizeItem","droppingDOMNode","l","getLayoutItem","cloneLayoutItem","placeholder","moveElement","compact","newLayout","onLayoutMaybeChanged","withLayoutItem","hasCollisions","collisions","getAllCollisions","filter","layoutItem","length","leastX","leastY","forEach","preventDefault","stopPropagation","nativeEvent","target","classList","contains","onDropDragOver","onDragOverResult","removeDroppingPlaceholder","finalDroppingItem","layerX","layerY","calculatedPosition","dragEnterCounter","item","find","prevState","newLayoutBase","isEqual","propsLayout","childrenEqual","fastRGLPropsEqual","nbRow","bottom","containerPaddingY","isDroppingItem","String","draggable","resizable","resizeHandlesOptions","bounded","mergedClassName","mergedStyle","containerHeight","noop","onDragLeave","onDragEnter","onDragOver","processGridItem","ReactGridLayoutPropTypes","type","obj","Object","prototype","toString","getIndentationValue","param","breakpoint","Array","isArray","ResponsiveReactGridLayout","generateInitialState","layouts","findOrGenerateResponsiveLayout","breakpoints","getBreakpointFromWidth","colNo","getColsFromBreakpoint","onWidthChange","newBreakpoint","lastBreakpoint","newCols","newLayouts","cloneLayout","onBreakpointChange","other","validateLayout","lg","md","sm","xs","xxs","WidthProvideRGL","ComposedComponent","HTMLElement","offsetWidth","window","addEventListener","onWindowResize","removeEventListener","measureBeforeMount","rest","sorted","sortBreakpoints","matching","len","breakpointName","breakpointsSorted","breakpointsAbove","slice","indexOf","b","correctBounds","sort","a","bottomY","modifyLayout","itemKey","cb","moved","c","collides","l1","l2","compareWith","getStatics","sortLayoutItems","compactItem","push","heightWidth","resolveCompactionCollision","moveToCoord","axis","sizeProp","map","otherItem","fullLayout","compactH","getFirstCollision","bounds","collidesWith","id","isUserAction","oldX","oldY","reverse","collision","moveElementAwayFromCollision","itemToMove","compactV","fakeItem","translate","transform","WebkitTransform","MozTransform","msTransform","OTransform","sortLayoutItemsByColRow","sortLayoutItemsByRowCol","initialLayout","exists","g","_grid","correctedLayout","contextName","subProps","j","toVal","mix","k","str","tmp","arguments","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","weakMapTag","arrayBufferTag","dataViewTag","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","freeSelf","Function","freeExports","nodeType","freeModule","moduleExports","freeProcess","process","nodeUtil","binding","nodeIsTypedArray","isTypedArray","arraySome","array","predicate","index","mapToArray","result","setToArray","set","uid","func","arrayProto","funcProto","objectProto","coreJsData","funcToString","hasOwnProperty","maskSrcKey","exec","IE_PROTO","nativeObjectToString","reIsNative","RegExp","replace","Buffer","Symbol","Uint8Array","propertyIsEnumerable","splice","symToStringTag","toStringTag","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","arg","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","Hash","entries","clear","entry","ListCache","MapCache","SetCache","values","__data__","add","Stack","data","assocIndexOf","eq","baseGetTag","isOwn","tag","unmasked","getRawTag","objectToString","baseIsArguments","isObjectLike","baseIsEqual","bitmask","customizer","stack","object","equalFunc","objIsArr","othIsArr","objTag","getTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","byteLength","byteOffset","buffer","name","message","convert","isPartial","stacked","get","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","getAllKeys","objLength","skipCtor","objValue","othValue","compared","objCtor","constructor","othCtor","equalObjects","baseIsEqualDeep","arrLength","othLength","seen","arrValue","othIndex","has","keysFunc","symbolsFunc","offset","arrayPush","baseGetAllKeys","getSymbols","getMapData","getValue","isObject","isMasked","isFunction","baseIsNative","pop","pairs","LARGE_ARRAY_SIZE","resIndex","symbol","arrayFilter","isIndex","ArrayBuffer","resolve","Ctor","ctorString","isArguments","isLength","baseUnary","inherited","isArr","isArg","isBuff","isType","skipIndexes","n","iteratee","baseTimes","arrayLikeKeys","baseKeys","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","componentName","location","propFullName","secret","err","getShim","isRequired","ReactPropTypes","bool","number","string","any","arrayOf","element","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","_typeof","iterator","defineProperty","enumerable","_DraggableCore","default","nodeInterop","__esModule","cache","_getRequireWildcardCache","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","desc","_interopRequireWildcard","_propTypes","_interopRequireDefault","_reactDom","_clsx2","_domFns","_positionFns","_shims","_log","_excluded","cacheBabelInterop","cacheNodeInterop","_extends","assign","source","apply","ownKeys","enumerableOnly","symbols","sym","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","_arrayLikeToArray","arr","arr2","_defineProperties","descriptor","configurable","writable","_setPrototypeOf","o","p","setPrototypeOf","__proto__","_possibleConstructorReturn","TypeError","_assertThisInitialized","ReferenceError","_getPrototypeOf","getPrototypeOf","Draggable","_React$Component","subClass","superClass","create","_inherits","Constructor","protoProps","staticProps","Derived","hasNativeReflectConstruct","_super","Reflect","construct","sham","Proxy","_isNativeReflectConstruct","Super","NewTarget","_this","instance","_classCallCheck","coreData","createDraggableData","dragged","uiData","newState","slackX","slackY","_getBoundPosition2","getBoundPosition","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","next","done","_iterableToArrayLimit","minLen","from","_unsupportedIterableToArray","_nonIterableRest","newStateX","newStateY","_this$props$position","defaultPosition","prevPropsPosition","isElementSVG","console","warn","_ref","_ref2","SVGElement","findDOMNode","_this$props$nodeRef$c","_this$props","_this$props$nodeRef","_clsx","_this$props2","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","positionOffset","draggableCoreProps","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","_objectWithoutProperties","svgTransform","validPosition","transformOpts","canDragX","canDragY","createSVGTransform","createCSSTransform","createElement","cloneElement","Children","only","Component","propTypes","right","dontSetMe","defaultProps","_slicedToArray","eventsFor","start","move","stop","dragEventFor","_len","args","_key","concat","lastX","NaN","lastY","touchIdentifier","onMouseDown","allowAnyClick","button","thisNode","ownerDocument","body","defaultView","Node","matchesSelectorAndParentsTo","getTouchIdentifier","getControlPosition","coreEvent","createCoreData","enableUserSelectHack","addUserSelectStyles","addEvent","handleDrag","handleDragStop","grid","_snapToGrid2","snapToGrid","MouseEvent","event","document","createEvent","initMouseEvent","removeUserSelectStyles","removeEvent","handleDragStart","onTouchStart","passive","onMouseUp","onTouchEnd","_require","matchesSelector","el","selector","baseNode","parentNode","inputOptions","options","capture","attachEvent","detachEvent","outerHeight","computedStyle","getComputedStyle","int","borderTopWidth","borderBottomWidth","outerWidth","clientWidth","borderLeftWidth","borderRightWidth","innerHeight","paddingTop","paddingBottom","innerWidth","paddingLeft","paddingRight","offsetXYFromParent","evt","offsetParentRect","clientX","clientY","controlPos","translation","getTranslation","_getPrefix","browserPrefixToKey","getTouch","identifier","targetTouches","findInArray","t","changedTouches","doc","styleEl","getElementById","innerHTML","getElementsByTagName","appendChild","addClassName","removeClassName","selection","empty","getSelection","removeAllRanges","matchesSelectorFunc","method","unitSuffix","defaultX","defaultY","match","remove","getPrefix","browserPrefixToStyle","prop","prefix","toLowerCase","prefixes","_window$document","_window$document$docu","documentElement","shouldCapitalize","toUpperCase","kebabToTitleCase","_default","cloneBounds","boundNode","ownerWindow","querySelector","boundNodeEl","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","marginRight","marginBottom","isNum","pendingX","pendingY","draggableCore","touchObj","isStart","callback","isNaN","parseInt","_reactDraggable","_utils","handleRefs","lastHandleRect","slack","_proto","componentWillUnmount","resetData","runConstraints","lockAspectRatio","ratio","deltaW","deltaH","abs","oldW","oldH","slackW","slackH","resizeHandler","_this2","axisV","axisH","handleRect","_this2$runConstraints","dimensionsChanged","persist","renderResizeHandle","handleAxis","render","_this3","handleSize","_this3$handleRefs$han","createRef","resizableProps","_Resizable","_propTypes2","ResizableBox","propsWidth","propsHeight","getDerivedStateFromProps","_react","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","getter","d","definition","globalThis","r","nmd","paths"],"sourceRoot":""}