{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///react-grid-layout.min.js","webpack:///webpack/bootstrap 038efeaf0f5ec9ce105f","webpack:///external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}","webpack:///./lib/utils.js","webpack:///./~/prop-types/index.js","webpack:///./~/lodash.isequal/index.js","webpack:///./lib/ReactGridLayout.jsx","webpack:///./lib/responsiveUtils.js","webpack:///./~/classnames/index.js","webpack:///./~/react-draggable/dist/react-draggable.js","webpack:///./~/react-resizable/build/Resizable.js","webpack:///external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}","webpack:///./lib/ResponsiveReactGridLayout.jsx","webpack:///./lib/components/WidthProvider.jsx","webpack:///./lib/GridItem.jsx","webpack:///./~/fbjs/lib/emptyFunction.js","webpack:///./~/fbjs/lib/invariant.js","webpack:///./~/prop-types/factoryWithThrowingShims.js","webpack:///./~/react-resizable/build/ResizableBox.js","webpack:///./~/react-resizable/build/cloneElement.js","webpack:///./~/react-resizable/index.js","webpack:///(webpack)/buildin/global.js","webpack:///(webpack)/buildin/module.js","webpack:///./index-dev.js"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE_0__","__WEBPACK_EXTERNAL_MODULE_9__","modules","__webpack_require__","moduleId","installedModules","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","_interopRequireDefault","obj","default","bottom","layout","max","bottomY","len","length","y","h","cloneLayout","newLayout","Array","cloneLayoutItem","layoutItem","w","x","minW","maxW","minH","maxH","moved","Boolean","static","isDraggable","isResizable","childrenEqual","a","b","_lodash2","_react2","Children","map","key","collides","l1","l2","compact","verticalCompact","compareWith","getStatics","sorted","sortLayoutItemsByRowCol","out","compactItem","push","indexOf","Math","min","getFirstCollision","correctBounds","bounds","collidesWith","cols","getLayoutItem","id","getAllCollisions","filter","moveElement","isUserAction","movingUp","reverse","collisions","collision","moveElementAwayFromCollision","itemToMove","fakeItem","undefined","perc","num","setTransform","_ref","top","left","width","height","translate","transform","WebkitTransform","MozTransform","msTransform","OTransform","position","setTopLeft","_ref2","concat","sort","synchronizeLayoutWithChildren","initialLayout","children","forEach","child","exists","isProduction","props","_grid","console","warn","g","validateLayout","contextName","subProps","isArray","Error","item","j","autoBindHandlers","el","fns","bind","_extends","assign","target","arguments","source","_lodash","_react","global","arrayFilter","array","predicate","index","resIndex","result","arrayPush","values","offset","arraySome","baseTimes","iteratee","baseUnary","func","cacheHas","cache","has","getValue","mapToArray","size","overArg","arg","setToArray","set","Hash","entries","clear","entry","hashClear","__data__","nativeCreate","hashDelete","hashGet","data","HASH_UNDEFINED","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","lastIndex","pop","splice","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","hash","Map","string","mapCacheDelete","getMapData","mapCacheGet","mapCacheHas","mapCacheSet","SetCache","add","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","pairs","LARGE_ARRAY_SIZE","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isBuffer","isType","isTypedArray","skipIndexes","String","isIndex","eq","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","undefinedTag","nullTag","symToStringTag","getRawTag","objectToString","baseIsArguments","isObjectLike","argsTag","baseIsEqual","other","bitmask","customizer","stack","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","arrayTag","getTag","othTag","objectTag","objIsObj","othIsObj","isSameTag","equalArrays","equalByTag","COMPARE_PARTIAL_FLAG","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","equalObjects","baseIsNative","isObject","isMasked","pattern","isFunction","reIsNative","reIsHostCtor","test","toSource","baseIsTypedArray","isLength","typedArrayTags","baseKeys","isPrototype","nativeKeys","isPartial","arrLength","othLength","stacked","seen","COMPARE_UNORDERED_FLAG","arrValue","othValue","compared","othIndex","tag","dataViewTag","byteLength","byteOffset","buffer","arrayBufferTag","Uint8Array","boolTag","dateTag","numberTag","errorTag","message","regexpTag","stringTag","mapTag","convert","setTag","symbolTag","symbolValueOf","objProps","getAllKeys","objLength","othProps","skipCtor","objValue","objCtor","constructor","othCtor","keys","getSymbols","isKeyable","getNative","isOwn","unmasked","e","nativeObjectToString","MAX_SAFE_INTEGER","reIsUint","type","maskSrcKey","Ctor","proto","objectProto","funcToString","isArrayLike","isEqual","funcTag","genTag","asyncTag","proxyTag","stubArray","stubFalse","promiseTag","weakMapTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reRegExpChar","freeGlobal","freeSelf","self","Function","freeExports","nodeType","freeModule","moduleExports","freeProcess","process","nodeUtil","binding","nodeIsTypedArray","arrayProto","funcProto","coreJsData","toString","uid","exec","IE_PROTO","RegExp","replace","Buffer","Symbol","propertyIsEnumerable","toStringTag","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","DataView","Promise","Set","WeakMap","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","valueOf","symbol","ArrayBuffer","resolve","ctorString","_classCallCheck","instance","Constructor","TypeError","_possibleConstructorReturn","ReferenceError","_inherits","subClass","superClass","create","writable","setPrototypeOf","__proto__","_propTypes","_propTypes2","_classnames","_classnames2","_utils","_GridItem","_GridItem2","noop","ReactGridLayout","_React$Component","context","_this","_initialiseProps","componentDidMount","setState","mounted","onLayoutMaybeChanged","state","componentWillReceiveProps","nextProps","newLayoutBase","oldLayout","containerHeight","autoSize","nbRow","containerPaddingY","containerPadding","margin","rowHeight","onDragStart","node","oldDragItem","onDrag","placeholder","activeDrag","onDragStop","_ref3","onLayoutChange","onResizeStart","_ref4","oldResizeItem","onResize","_ref5","_state","onResizeStop","_ref6","_state2","_props","maxRows","useCSSTransforms","createElement","className","containerWidth","processGridItem","_props2","draggableCancel","draggableHandle","draggable","resizable","cancel","handle","usePercentages","render","_this2","_props3","style","mergedStyle","Component","displayName","propTypes","number","bool","arrayOf","propName","_componentName","defaultProps","Infinity","getBreakpointFromWidth","breakpoints","sortBreakpoints","matching","breakpointName","getColsFromBreakpoint","breakpoint","findOrGenerateResponsiveLayout","layouts","lastBreakpoint","breakpointsSorted","breakpointsAbove","slice","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","classNames","classes","argType","apply","hasOwn","join","__WEBPACK_EXTERNAL_MODULE_2__","__WEBPACK_EXTERNAL_MODULE_3__","loaded","DraggableCore","_defineProperty","_slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","iterator","next","done","err","_createClass","defineProperties","descriptor","protoProps","staticProps","_reactDom","_reactDom2","_domFns","_positionFns","_shims","_DraggableCore","_DraggableCore2","_log","_log2","Draggable","getPrototypeOf","coreData","shouldStart","onStart","createDraggableData","dragging","dragged","uiData","newState","_x","_y","slackX","slackY","_getBoundPosition","getBoundPosition","_getBoundPosition2","deltaX","deltaY","shouldUpdate","shouldStop","onStop","controlled","_this$props$position","_x2","_y2","defaultPosition","isElementSVG","SVGElement","findDOMNode","_classNames","svgTransform","transformOpts","canDragX","canDragY","createSVGTransform","createCSSTransform","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","cloneElement","only","axis","PropTypes","oneOf","oneOfType","shape","right","dontSetMe","matchesSelector","selector","matchesSelectorFunc","findInArray","method","matchesSelectorAndParentsTo","baseNode","parentNode","addEvent","event","handler","attachEvent","addEventListener","removeEvent","detachEvent","removeEventListener","outerHeight","clientHeight","computedStyle","ownerDocument","defaultView","getComputedStyle","int","borderTopWidth","borderBottomWidth","outerWidth","clientWidth","borderLeftWidth","borderRightWidth","innerHeight","paddingTop","paddingBottom","innerWidth","paddingLeft","paddingRight","offsetXYFromParent","evt","offsetParent","isBody","body","offsetParentRect","getBoundingClientRect","clientX","scrollLeft","clientY","scrollTop","_getPrefix","browserPrefixToKey","_getPrefix2","getTouch","identifier","targetTouches","t","changedTouches","getTouchIdentifier","addUserSelectStyles","getAttribute","setAttribute","userSelectStyle","removeUserSelectStyles","userSelectReplaceRegExp","styleHacks","childStyle","touchAction","userSelectPrefix","getPrefix","userSelect","browserPrefixToStyle","callback","isNum","isNaN","parseInt","componentName","prop","window","document","documentElement","prefixes","prefix","kebabToTitleCase","toLowerCase","str","shouldCapitalize","toUpperCase","cloneBounds","ownerWindow","boundNode","querySelector","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","snapToGrid","grid","pendingX","pendingY","round","getControlPosition","touchIdentifier","draggableCore","touchObj","createCoreData","isStart","lastX","lastY","eventsFor","touch","start","move","stop","mouse","dragEventFor","_temp","_ret","_len","args","_key","NaN","handleDragStart","onMouseDown","allowAnyClick","button","domNode","disabled","Node","coreEvent","enableUserSelectHack","handleDrag","handleDragStop","preventDefault","_snapToGrid","_snapToGrid2","MouseEvent","createEvent","initMouseEvent","_ReactDOM$findDOMNode","onMouseUp","onTouchStart","onTouchEnd","_ReactDOM$findDOMNode2","browser","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","timeout","run","Item","nextTick","title","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","cwd","chdir","dir","umask","log","_objectWithoutProperties","_reactDraggable","_cloneElement","_cloneElement2","Resizable","resizing","slackW","slackH","lockAspectRatio","aspectRatio","runConstraints","minConstraints","maxConstraints","ratio","oldW","oldH","resizeHandler","handlerName","widthChanged","heightChanged","_runConstraints","hasCb","persist","draggableOpts","handleSize","element","isRequired","_responsiveUtils","_ReactGridLayout","_ReactGridLayout2","ResponsiveReactGridLayout","generateInitialState","_extends2","colNo","onWidthChange","newBreakpoint","newCols","onBreakpointChange","lg","md","sm","xs","xxs","WidthProvider","ComposedComponent","_class","_temp2","onWindowResize","_event","HTMLElement","offsetWidth","componentWillUnmount","measureBeforeMount","_reactResizable","GridItem","calcColWidth","calcPosition","colWidth","calcXY","calcWH","_props4","createStyle","pos","_props5","mixinDraggable","onDragHandler","mixinResizable","_props6","maxWidth","mins","maxes","onResizeHandler","newPosition","parentRect","clientRect","_calcXY","_this3","_props7","_calcWH","_props8","newChild","react-draggable","react-draggable-dragging","cssTransforms","makeEmptyFunction","emptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","invariant","condition","format","f","validateFormat","error","argIndex","framesToPop","shim","getShim","ReactPropTypes","any","instanceOf","objectOf","checkPropTypes","_Resizable","_Resizable2","ResizableBox","eval","webpackPolyfill","deprecate","paths","utils","Responsive"],"mappings":"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","file":"react-grid-layout.min.js","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})(this, function(__WEBPACK_EXTERNAL_MODULE_0__, __WEBPACK_EXTERNAL_MODULE_9__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(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})(this, function(__WEBPACK_EXTERNAL_MODULE_0__, __WEBPACK_EXTERNAL_MODULE_9__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 21);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_0__;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports.bottom = bottom;\nexports.cloneLayout = cloneLayout;\nexports.cloneLayoutItem = cloneLayoutItem;\nexports.childrenEqual = childrenEqual;\nexports.collides = collides;\nexports.compact = compact;\nexports.compactItem = compactItem;\nexports.correctBounds = correctBounds;\nexports.getLayoutItem = getLayoutItem;\nexports.getFirstCollision = getFirstCollision;\nexports.getAllCollisions = getAllCollisions;\nexports.getStatics = getStatics;\nexports.moveElement = moveElement;\nexports.moveElementAwayFromCollision = moveElementAwayFromCollision;\nexports.perc = perc;\nexports.setTransform = setTransform;\nexports.setTopLeft = setTopLeft;\nexports.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;\nexports.synchronizeLayoutWithChildren = synchronizeLayoutWithChildren;\nexports.validateLayout = validateLayout;\nexports.autoBindHandlers = autoBindHandlers;\n\nvar _lodash = __webpack_require__(3);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar isProduction = \"production\" === 'production';\n\n/**\n * Return the bottom coordinate of the layout.\n *\n * @param {Array} layout Layout array.\n * @return {Number} Bottom coordinate.\n */\nfunction bottom(layout) {\n var max = 0,\n bottomY = void 0;\n for (var _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\nfunction cloneLayout(layout) {\n var newLayout = Array(layout.length);\n for (var _i2 = 0, len = layout.length; _i2 < len; _i2++) {\n newLayout[_i2] = cloneLayoutItem(layout[_i2]);\n }\n return newLayout;\n}\n\n// Fast path to cloning, since this is monomorphic\nfunction cloneLayoutItem(layoutItem) {\n return {\n w: layoutItem.w, h: layoutItem.h, x: layoutItem.x, y: layoutItem.y, i: layoutItem.i,\n minW: layoutItem.minW, maxW: layoutItem.maxW, minH: layoutItem.minH, maxH: layoutItem.maxH,\n moved: Boolean(layoutItem.moved), static: Boolean(layoutItem.static),\n // These can be null\n isDraggable: layoutItem.isDraggable, isResizable: layoutItem.isResizable\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 */\nfunction childrenEqual(a, b) {\n return (0, _lodash2.default)(_react2.default.Children.map(a, function (c) {\n return c.key;\n }), _react2.default.Children.map(b, function (c) {\n return c.key;\n }));\n}\n\n/**\n * Given two layoutitems, check if they collide.\n */\nfunction collides(l1, l2) {\n if (l1 === l2) 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 * @param {Array} layout Layout.\n * @param {Boolean} verticalCompact Whether or not to compact the layout\n * vertically.\n * @return {Array} Compacted Layout.\n */\nfunction compact(layout, verticalCompact) {\n // Statics go in the compareWith array right away so items flow around them.\n var compareWith = getStatics(layout);\n // We go through the items by row and column.\n var sorted = sortLayoutItemsByRowCol(layout);\n // Holding for new items.\n var out = Array(layout.length);\n\n for (var _i3 = 0, len = sorted.length; _i3 < len; _i3++) {\n var l = cloneLayoutItem(sorted[_i3]);\n\n // Don't move static elements\n if (!l.static) {\n l = compactItem(compareWith, l, verticalCompact);\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[_i3])] = l;\n\n // Clear moved flag, if it exists.\n l.moved = false;\n }\n\n return out;\n}\n\n/**\n * Compact an item in the layout.\n */\nfunction compactItem(compareWith, l, verticalCompact) {\n if (verticalCompact) {\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\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 }\n\n // Move it down, and keep moving it down if it's colliding.\n var collides = void 0;\n while (collides = getFirstCollision(compareWith, l)) {\n l.y = collides.y + collides.h;\n }\n return l;\n}\n\n/**\n * Given a layout, make sure all elements fit within its bounds.\n *\n * @param {Array} layout Layout array.\n * @param {Number} bounds Number of columns.\n */\nfunction correctBounds(layout, bounds) {\n var collidesWith = getStatics(layout);\n for (var _i4 = 0, len = layout.length; _i4 < len; _i4++) {\n var l = layout[_i4];\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);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 */\nfunction getLayoutItem(layout, id) {\n for (var _i5 = 0, len = layout.length; _i5 < len; _i5++) {\n if (layout[_i5].i === id) return layout[_i5];\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 */\nfunction getFirstCollision(layout, layoutItem) {\n for (var _i6 = 0, len = layout.length; _i6 < len; _i6++) {\n if (collides(layout[_i6], layoutItem)) return layout[_i6];\n }\n}\n\nfunction getAllCollisions(layout, layoutItem) {\n return layout.filter(function (l) {\n return collides(l, layoutItem);\n });\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 */\nfunction getStatics(layout) {\n return layout.filter(function (l) {\n return l.static;\n });\n}\n\n/**\n * Move an element. Responsible for doing cascading movements of other elements.\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 * @param {Boolean} [isUserAction] If true, designates that the item we're moving is\n * being dragged/resized by the user.\n */\nfunction moveElement(layout, l, x, y, isUserAction) {\n if (l.static) return layout;\n\n // Short-circuit if nothing to do.\n if (l.y === y && l.x === x) return layout;\n\n var movingUp = y && l.y > y;\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 var sorted = sortLayoutItemsByRowCol(layout);\n if (movingUp) sorted = sorted.reverse();\n var collisions = getAllCollisions(sorted, l);\n\n // Move each item that collides away from this element.\n for (var _i7 = 0, len = collisions.length; _i7 < len; _i7++) {\n var collision = collisions[_i7];\n // console.log('resolving collision between', l.i, 'at', l.y, 'and', collision.i, 'at', collision.y);\n\n // Short circuit so we can't infinite loop\n if (collision.moved) continue;\n\n // This makes it feel a bit more precise by waiting to swap for just a bit when moving up.\n if (l.y > collision.y && l.y - collision.y > collision.h / 4) continue;\n\n // Don't move static items - we have to move *this* element away\n if (collision.static) {\n layout = moveElementAwayFromCollision(layout, collision, l, isUserAction);\n } else {\n layout = moveElementAwayFromCollision(layout, l, collision, isUserAction);\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 * @param {Boolean} [isUserAction] If true, designates that the item we're moving is being dragged/resized\n * by the user.\n */\nfunction moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction) {\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 // Make a mock item so we don't modify the item here, only modify in moveElement.\n var fakeItem = {\n x: itemToMove.x,\n y: itemToMove.y,\n w: itemToMove.w,\n h: itemToMove.h,\n i: '-1'\n };\n fakeItem.y = Math.max(collidesWith.y - itemToMove.h, 0);\n if (!getFirstCollision(layout, fakeItem)) {\n return moveElement(layout, itemToMove, undefined, fakeItem.y);\n }\n }\n\n // Previously this was optimized to move below the collision directly, but this can cause problems\n // with cascading moves, as an item may actually leapfrog a collision and cause a reversal in order.\n return moveElement(layout, itemToMove, undefined, itemToMove.y + 1);\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 */\nfunction perc(num) {\n return num * 100 + '%';\n}\n\nfunction setTransform(_ref) {\n var top = _ref.top,\n left = _ref.left,\n width = _ref.width,\n height = _ref.height;\n\n // Replace unitless items with px\n var 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\nfunction setTopLeft(_ref2) {\n var top = _ref2.top,\n left = _ref2.left,\n width = _ref2.width,\n height = _ref2.height;\n\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 */\nfunction sortLayoutItemsByRowCol(layout) {\n return [].concat(layout).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 * Generate a layout using the initialLayout and children as a template.\n * Missing entries will be added, extraneous ones will be truncated.\n *\n * @param {Array} initialLayout Layout passed in through props.\n * @param {String} breakpoint Current responsive breakpoint.\n * @param {Boolean} verticalCompact Whether or not to compact the layout vertically.\n * @return {Array} Working layout.\n */\nfunction synchronizeLayoutWithChildren(initialLayout, children, cols, verticalCompact) {\n initialLayout = initialLayout || [];\n\n // Generate one layout item per child.\n var layout = [];\n _react2.default.Children.forEach(children, function (child, i) {\n // Don't overwrite if it already exists.\n var exists = getLayoutItem(initialLayout, child.key || \"1\" /* FIXME satisfies Flow */);\n if (exists) {\n layout[i] = cloneLayoutItem(exists);\n } else {\n if (!isProduction && child.props._grid) {\n console.warn('`_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 var 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\n layout[i] = cloneLayoutItem(_extends({}, g, { i: child.key }));\n } else {\n // Nothing provided: ensure this is added to the bottom\n layout[i] = cloneLayoutItem({ w: 1, h: 1, x: 0, y: bottom(layout), i: child.key || \"1\" });\n }\n }\n });\n\n // Correct the layout.\n layout = correctBounds(layout, { cols: cols });\n layout = compact(layout, verticalCompact);\n\n return layout;\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 */\nfunction validateLayout(layout, contextName) {\n contextName = contextName || \"Layout\";\n var subProps = ['x', 'y', 'w', 'h'];\n if (!Array.isArray(layout)) throw new Error(contextName + \" must be an array!\");\n for (var _i8 = 0, len = layout.length; _i8 < len; _i8++) {\n var item = layout[_i8];\n for (var j = 0; j < subProps.length; j++) {\n if (typeof item[subProps[j]] !== 'number') {\n throw new Error('ReactGridLayout: ' + contextName + '[' + _i8 + '].' + subProps[j] + ' must be a number!');\n }\n }\n if (item.i && typeof item.i !== 'string') {\n throw new Error('ReactGridLayout: ' + contextName + '[' + _i8 + '].i must be a string!');\n }\n if (item.static !== undefined && typeof item.static !== 'boolean') {\n throw new Error('ReactGridLayout: ' + contextName + '[' + _i8 + '].static must be a boolean!');\n }\n }\n}\n\n// Flow can't really figure this out, so we just use Object\nfunction autoBindHandlers(el, fns) {\n fns.forEach(function (key) {\n return el[key] = el[key].bind(el);\n });\n}\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\nif (false) {\n var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n Symbol.for &&\n Symbol.for('react.element')) ||\n 0xeac7;\n\n var isValidElement = function(object) {\n return typeof object === 'object' &&\n object !== null &&\n object.$$typeof === REACT_ELEMENT_TYPE;\n };\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')(isValidElement, 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 = __webpack_require__(15)();\n}\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, module) {/**\n * Lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \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/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(19), __webpack_require__(20)(module)))\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(2);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _lodash = __webpack_require__(3);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nvar _classnames = __webpack_require__(6);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _utils = __webpack_require__(1);\n\nvar _GridItem = __webpack_require__(12);\n\nvar _GridItem2 = _interopRequireDefault(_GridItem);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar noop = function noop() {};\n\n// Types\n\n// End Types\n\n/**\n * A reactive, fluid grid layout with draggable, resizable components.\n */\n\nvar ReactGridLayout = function (_React$Component) {\n _inherits(ReactGridLayout, _React$Component);\n\n // TODO publish internal ReactClass displayName transform\n function ReactGridLayout(props, context) {\n _classCallCheck(this, ReactGridLayout);\n\n var _this = _possibleConstructorReturn(this, _React$Component.call(this, props, context));\n\n _initialiseProps.call(_this);\n\n (0, _utils.autoBindHandlers)(_this, ['onDragStart', 'onDrag', 'onDragStop', 'onResizeStart', 'onResize', 'onResizeStop']);\n return _this;\n }\n\n ReactGridLayout.prototype.componentDidMount = function 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 ReactGridLayout.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n var newLayoutBase = void 0;\n // Allow parent to set layout directly.\n if (!(0, _lodash2.default)(nextProps.layout, this.props.layout)) {\n newLayoutBase = nextProps.layout;\n }\n\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 else if (!(0, _utils.childrenEqual)(this.props.children, nextProps.children)) {\n newLayoutBase = this.state.layout;\n }\n\n // We need to regenerate the layout.\n if (newLayoutBase) {\n var newLayout = (0, _utils.synchronizeLayoutWithChildren)(newLayoutBase, nextProps.children, nextProps.cols, nextProps.verticalCompact);\n var _oldLayout = this.state.layout;\n this.setState({ layout: newLayout });\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\n\n ReactGridLayout.prototype.containerHeight = function containerHeight() {\n if (!this.props.autoSize) return;\n var nbRow = (0, _utils.bottom)(this.state.layout);\n var containerPaddingY = this.props.containerPadding ? this.props.containerPadding[1] : this.props.margin[1];\n return nbRow * this.props.rowHeight + (nbRow - 1) * this.props.margin[1] + containerPaddingY * 2 + 'px';\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\n\n ReactGridLayout.prototype.onDragStart = function onDragStart(i, x, y, _ref) {\n var e = _ref.e,\n node = _ref.node;\n var layout = this.state.layout;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n if (!l) return;\n\n this.setState({ oldDragItem: (0, _utils.cloneLayoutItem)(l), oldLayout: this.state.layout });\n\n 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\n\n ReactGridLayout.prototype.onDrag = function onDrag(i, x, y, _ref2) {\n var e = _ref2.e,\n node = _ref2.node;\n var oldDragItem = this.state.oldDragItem;\n var layout = this.state.layout;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n if (!l) return;\n\n // Create placeholder (display only)\n var placeholder = {\n w: l.w, h: l.h, x: l.x, y: l.y, placeholder: true, i: i\n };\n\n // Move the element to the dragged location.\n layout = (0, _utils.moveElement)(layout, l, x, y, true /* isUserAction */);\n\n this.props.onDrag(layout, oldDragItem, l, placeholder, e, node);\n\n this.setState({\n layout: (0, _utils.compact)(layout, this.props.verticalCompact),\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\n\n ReactGridLayout.prototype.onDragStop = function onDragStop(i, x, y, _ref3) {\n var e = _ref3.e,\n node = _ref3.node;\n var oldDragItem = this.state.oldDragItem;\n var layout = this.state.layout;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n if (!l) return;\n\n // Move the element here\n layout = (0, _utils.moveElement)(layout, l, x, y, true /* isUserAction */);\n\n this.props.onDragStop(layout, oldDragItem, l, null, e, node);\n\n // Set state\n var newLayout = (0, _utils.compact)(layout, this.props.verticalCompact);\n var oldLayout = this.state.oldLayout;\n\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 ReactGridLayout.prototype.onLayoutMaybeChanged = function onLayoutMaybeChanged(newLayout, oldLayout) {\n if (!oldLayout) oldLayout = this.state.layout;\n if (!(0, _lodash2.default)(oldLayout, newLayout)) {\n this.props.onLayoutChange(newLayout);\n }\n };\n\n ReactGridLayout.prototype.onResizeStart = function onResizeStart(i, w, h, _ref4) {\n var e = _ref4.e,\n node = _ref4.node;\n var layout = this.state.layout;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n if (!l) return;\n\n this.setState({\n oldResizeItem: (0, _utils.cloneLayoutItem)(l),\n oldLayout: this.state.layout\n });\n\n this.props.onResizeStart(layout, l, l, null, e, node);\n };\n\n ReactGridLayout.prototype.onResize = function onResize(i, w, h, _ref5) {\n var e = _ref5.e,\n node = _ref5.node;\n var _state = this.state,\n layout = _state.layout,\n oldResizeItem = _state.oldResizeItem;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n if (!l) return;\n\n // Set new width and height.\n l.w = w;\n l.h = h;\n\n // Create placeholder element (display only)\n var placeholder = {\n w: w, h: h, x: l.x, y: l.y, static: true, i: i\n };\n\n this.props.onResize(layout, oldResizeItem, l, placeholder, e, node);\n\n // Re-compact the layout and set the drag placeholder.\n this.setState({\n layout: (0, _utils.compact)(layout, this.props.verticalCompact),\n activeDrag: placeholder\n });\n };\n\n ReactGridLayout.prototype.onResizeStop = function onResizeStop(i, w, h, _ref6) {\n var e = _ref6.e,\n node = _ref6.node;\n var _state2 = this.state,\n layout = _state2.layout,\n oldResizeItem = _state2.oldResizeItem;\n\n var l = (0, _utils.getLayoutItem)(layout, i);\n\n this.props.onResizeStop(layout, oldResizeItem, l, null, e, node);\n\n // Set state\n var newLayout = (0, _utils.compact)(layout, this.props.verticalCompact);\n var oldLayout = this.state.oldLayout;\n\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\n\n ReactGridLayout.prototype.placeholder = function placeholder() {\n var activeDrag = this.state.activeDrag;\n\n if (!activeDrag) return null;\n var _props = this.props,\n width = _props.width,\n cols = _props.cols,\n margin = _props.margin,\n containerPadding = _props.containerPadding,\n rowHeight = _props.rowHeight,\n maxRows = _props.maxRows,\n useCSSTransforms = _props.useCSSTransforms;\n\n // {...this.state.activeDrag} is pretty slow, actually\n\n return _react2.default.createElement(\n _GridItem2.default,\n {\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 useCSSTransforms: useCSSTransforms },\n _react2.default.createElement('div', null)\n );\n };\n\n /**\n * Given a grid item, set its style attributes & surround in a .\n * @param {Element} child React element.\n * @return {Element} Element wrapped in draggable and properly placed.\n */\n\n\n ReactGridLayout.prototype.processGridItem = function processGridItem(child) {\n if (!child.key) return;\n var l = (0, _utils.getLayoutItem)(this.state.layout, child.key);\n if (!l) return null;\n var _props2 = this.props,\n width = _props2.width,\n cols = _props2.cols,\n margin = _props2.margin,\n containerPadding = _props2.containerPadding,\n rowHeight = _props2.rowHeight,\n maxRows = _props2.maxRows,\n isDraggable = _props2.isDraggable,\n isResizable = _props2.isResizable,\n useCSSTransforms = _props2.useCSSTransforms,\n draggableCancel = _props2.draggableCancel,\n draggableHandle = _props2.draggableHandle;\n var mounted = this.state.mounted;\n\n // Parse 'static'. Any properties defined directly on the grid item will take precedence.\n\n var draggable = Boolean(!l.static && isDraggable && (l.isDraggable || l.isDraggable == null));\n var resizable = Boolean(!l.static && isResizable && (l.isResizable || l.isResizable == null));\n\n return _react2.default.createElement(\n _GridItem2.default,\n {\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 useCSSTransforms: useCSSTransforms && mounted,\n usePercentages: !mounted,\n\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 },\n child\n );\n };\n\n ReactGridLayout.prototype.render = function render() {\n var _this2 = this;\n\n var _props3 = this.props,\n className = _props3.className,\n style = _props3.style;\n\n\n var mergedStyle = _extends({\n height: this.containerHeight()\n }, style);\n\n return _react2.default.createElement(\n 'div',\n { className: (0, _classnames2.default)('react-grid-layout', className), style: mergedStyle },\n _react2.default.Children.map(this.props.children, function (child) {\n return _this2.processGridItem(child);\n }),\n this.placeholder()\n );\n };\n\n return ReactGridLayout;\n}(_react2.default.Component);\n\nReactGridLayout.displayName = \"ReactGridLayout\";\nReactGridLayout.propTypes = {\n //\n // Basic props\n //\n className: _propTypes2.default.string,\n style: _propTypes2.default.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: _propTypes2.default.number,\n\n // If true, the container height swells and contracts to fit contents\n autoSize: _propTypes2.default.bool,\n // # of cols.\n cols: _propTypes2.default.number,\n\n // A selector that will not be draggable.\n draggableCancel: _propTypes2.default.string,\n // A selector for the draggable handler\n draggableHandle: _propTypes2.default.string,\n\n // If true, the layout will compact vertically\n verticalCompact: _propTypes2.default.bool,\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 layout(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 (0, _utils.validateLayout)(layout, 'layout');\n },\n\n //\n // Grid Dimensions\n //\n\n // Margin between items [x, y] in px\n margin: _propTypes2.default.arrayOf(_propTypes2.default.number),\n // Padding inside the container [x, y] in px\n containerPadding: _propTypes2.default.arrayOf(_propTypes2.default.number),\n // Rows have a static height, but you can change this based on breakpoints if you like\n rowHeight: _propTypes2.default.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: _propTypes2.default.number,\n\n //\n // Flags\n //\n isDraggable: _propTypes2.default.bool,\n isResizable: _propTypes2.default.bool,\n // Use CSS transforms instead of top/left\n useCSSTransforms: _propTypes2.default.bool,\n\n //\n // Callbacks\n //\n\n // Callback so you can save the layout. Calls after each drag & resize stops.\n onLayoutChange: _propTypes2.default.func,\n\n // Calls when drag starts. Callback is of the signature (layout, oldItem, newItem, placeholder, e).\n // All callbacks below have the same signature. 'start' and 'stop' callbacks omit the 'placeholder'.\n onDragStart: _propTypes2.default.func,\n // Calls on each drag movement.\n onDrag: _propTypes2.default.func,\n // Calls when drag is complete.\n onDragStop: _propTypes2.default.func,\n //Calls when resize starts.\n onResizeStart: _propTypes2.default.func,\n // Calls when resize movement happens.\n onResize: _propTypes2.default.func,\n // Calls when resize is complete.\n onResizeStop: _propTypes2.default.func,\n\n //\n // Other validations\n //\n\n // Children must not have duplicate keys.\n children: function children(props, propName, _componentName) {\n var children = props[propName];\n\n // Check children keys for duplicates. Throw if found.\n var keys = {};\n _react2.default.Children.forEach(children, function (child) {\n if (keys[child.key]) {\n throw new Error(\"Duplicate child key found! This will cause problems in ReactGridLayout.\");\n }\n keys[child.key] = true;\n });\n }\n};\nReactGridLayout.defaultProps = {\n autoSize: true,\n cols: 12,\n className: '',\n rowHeight: 150,\n maxRows: Infinity, // infinite vertical growth\n layout: [],\n margin: [10, 10],\n isDraggable: true,\n isResizable: true,\n useCSSTransforms: true,\n verticalCompact: true,\n onLayoutChange: noop,\n onDragStart: noop,\n onDrag: noop,\n onDragStop: noop,\n onResizeStart: noop,\n onResize: noop,\n onResizeStop: noop\n};\n\nvar _initialiseProps = function _initialiseProps() {\n this.state = {\n activeDrag: null,\n layout: (0, _utils.synchronizeLayoutWithChildren)(this.props.layout, this.props.children, this.props.cols, this.props.verticalCompact),\n mounted: false,\n oldDragItem: null,\n oldLayout: null,\n oldResizeItem: null\n };\n};\n\nexports.default = ReactGridLayout;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\nexports.getBreakpointFromWidth = getBreakpointFromWidth;\nexports.getColsFromBreakpoint = getColsFromBreakpoint;\nexports.findOrGenerateResponsiveLayout = findOrGenerateResponsiveLayout;\nexports.sortBreakpoints = sortBreakpoints;\n\nvar _utils = __webpack_require__(1);\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 */\nfunction getBreakpointFromWidth(breakpoints, width) {\n var sorted = sortBreakpoints(breakpoints);\n var matching = sorted[0];\n for (var i = 1, len = sorted.length; i < len; i++) {\n var 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 */\n\n\nfunction getColsFromBreakpoint(breakpoint, cols) {\n if (!cols[breakpoint]) {\n throw new Error(\"ResponsiveReactGridLayout: `cols` entry for breakpoint \" + breakpoint + \" is missing!\");\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 */\nfunction findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBreakpoint, cols, verticalCompact) {\n // If it already exists, just return it.\n if (layouts[breakpoint]) return (0, _utils.cloneLayout)(layouts[breakpoint]);\n // Find or generate the next layout\n var layout = layouts[lastBreakpoint];\n var breakpointsSorted = sortBreakpoints(breakpoints);\n var breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));\n for (var i = 0, len = breakpointsAbove.length; i < len; i++) {\n var b = breakpointsAbove[i];\n if (layouts[b]) {\n layout = layouts[b];\n break;\n }\n }\n layout = (0, _utils.cloneLayout)(layout || []); // clone layout so we don't modify existing items\n return (0, _utils.compact)((0, _utils.correctBounds)(layout, { cols: cols }), verticalCompact);\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 */\nfunction sortBreakpoints(breakpoints) {\n var keys = Object.keys(breakpoints);\n return keys.sort(function (a, b) {\n return breakpoints[a] - breakpoints[b];\n });\n}\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n Copyright (c) 2016 Jed Watson.\n Licensed under the MIT License (MIT), see\n http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = classNames;\n\t} else if (true) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\t\treturn classNames;\n\t\t}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(true)\n\t\tmodule.exports = factory(__webpack_require__(0), __webpack_require__(9));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\", \"react-dom\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactDraggable\"] = factory(require(\"react\"), require(\"react-dom\"));\n\telse\n\t\troot[\"ReactDraggable\"] = factory(root[\"React\"], root[\"ReactDOM\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(1).default;\n\tmodule.exports.DraggableCore = __webpack_require__(9).default;\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _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; };\n\t\n\tvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_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\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\t\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _react = __webpack_require__(2);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _classnames = __webpack_require__(4);\n\t\n\tvar _classnames2 = _interopRequireDefault(_classnames);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tvar _positionFns = __webpack_require__(8);\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _DraggableCore = __webpack_require__(9);\n\t\n\tvar _DraggableCore2 = _interopRequireDefault(_DraggableCore);\n\t\n\tvar _log = __webpack_require__(11);\n\t\n\tvar _log2 = _interopRequireDefault(_log);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _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\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t// $FlowIgnore\n\t\n\t\n\t/*:: import type {DraggableEventHandler} from './utils/types';*/\n\t/*:: type DraggableState = {\n\t dragging: boolean,\n\t dragged: boolean,\n\t x: number, y: number,\n\t slackX: number, slackY: number,\n\t isElementSVG: boolean\n\t};*/\n\t\n\t\n\t//\n\t// Define \n\t//\n\t\n\t/*:: type ConstructorProps = {\n\t position: { x: number, y: number },\n\t defaultPosition: { x: number, y: number }\n\t};*/\n\t\n\tvar Draggable = function (_React$Component) {\n\t _inherits(Draggable, _React$Component);\n\t\n\t function Draggable(props /*: ConstructorProps*/) {\n\t _classCallCheck(this, Draggable);\n\t\n\t var _this = _possibleConstructorReturn(this, (Draggable.__proto__ || Object.getPrototypeOf(Draggable)).call(this, props));\n\t\n\t _this.onDragStart = function (e, coreData) {\n\t (0, _log2.default)('Draggable: onDragStart: %j', coreData);\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_this, coreData));\n\t // Kills start event on core as well, so move handlers are never bound.\n\t if (shouldStart === false) return false;\n\t\n\t _this.setState({ dragging: true, dragged: true });\n\t };\n\t\n\t _this.onDrag = function (e, coreData) {\n\t if (!_this.state.dragging) return false;\n\t (0, _log2.default)('Draggable: onDrag: %j', coreData);\n\t\n\t var uiData = (0, _positionFns.createDraggableData)(_this, coreData);\n\t\n\t var newState /*: $Shape*/ = {\n\t x: uiData.x,\n\t y: uiData.y\n\t };\n\t\n\t // Keep within bounds.\n\t if (_this.props.bounds) {\n\t // Save original x and y.\n\t var _x = newState.x,\n\t _y = newState.y;\n\t\n\t // Add slack to the values used to calculate bound position. This will ensure that if\n\t // we start removing slack, the element won't react to it right away until it's been\n\t // completely removed.\n\t\n\t newState.x += _this.state.slackX;\n\t newState.y += _this.state.slackY;\n\t\n\t // Get bound position. This will ceil/floor the x and y within the boundaries.\n\t // $FlowBug\n\t\n\t // Recalculate slack by noting how much was shaved by the boundPosition handler.\n\t var _getBoundPosition = (0, _positionFns.getBoundPosition)(_this, newState.x, newState.y);\n\t\n\t var _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2);\n\t\n\t newState.x = _getBoundPosition2[0];\n\t newState.y = _getBoundPosition2[1];\n\t newState.slackX = _this.state.slackX + (_x - newState.x);\n\t newState.slackY = _this.state.slackY + (_y - newState.y);\n\t\n\t // Update the event we fire to reflect what really happened after bounds took effect.\n\t uiData.x = _x;\n\t uiData.y = _y;\n\t uiData.deltaX = newState.x - _this.state.x;\n\t uiData.deltaY = newState.y - _this.state.y;\n\t }\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldUpdate = _this.props.onDrag(e, uiData);\n\t if (shouldUpdate === false) return false;\n\t\n\t _this.setState(newState);\n\t };\n\t\n\t _this.onDragStop = function (e, coreData) {\n\t if (!_this.state.dragging) return false;\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldStop = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_this, coreData));\n\t if (shouldStop === false) return false;\n\t\n\t (0, _log2.default)('Draggable: onDragStop: %j', coreData);\n\t\n\t var newState /*: $Shape*/ = {\n\t dragging: false,\n\t slackX: 0,\n\t slackY: 0\n\t };\n\t\n\t // If this is a controlled component, the result of this operation will be to\n\t // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n\t var controlled = Boolean(_this.props.position);\n\t if (controlled) {\n\t var _this$props$position = _this.props.position,\n\t _x2 = _this$props$position.x,\n\t _y2 = _this$props$position.y;\n\t\n\t newState.x = _x2;\n\t newState.y = _y2;\n\t }\n\t\n\t _this.setState(newState);\n\t };\n\t\n\t _this.state = {\n\t // Whether or not we are currently dragging.\n\t dragging: false,\n\t\n\t // Whether or not we have been dragged before.\n\t dragged: false,\n\t\n\t // Current transform x and y.\n\t x: props.position ? props.position.x : props.defaultPosition.x,\n\t y: props.position ? props.position.y : props.defaultPosition.y,\n\t\n\t // Used for compensating for out-of-bounds drags\n\t slackX: 0, slackY: 0,\n\t\n\t // Can only determine if SVG after mounting\n\t isElementSVG: false\n\t };\n\t return _this;\n\t }\n\t\n\t _createClass(Draggable, [{\n\t key: 'componentWillMount',\n\t value: function componentWillMount() {\n\t if (this.props.position && !(this.props.onDrag || this.props.onStop)) {\n\t // eslint-disable-next-line\n\t console.warn('A `position` was applied to this , 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\t }\n\t }\n\t }, {\n\t key: 'componentDidMount',\n\t value: function componentDidMount() {\n\t // Check to see if the element passed is an instanceof SVGElement\n\t if (typeof SVGElement !== 'undefined' && _reactDom2.default.findDOMNode(this) instanceof SVGElement) {\n\t this.setState({ isElementSVG: true });\n\t }\n\t }\n\t }, {\n\t key: 'componentWillReceiveProps',\n\t value: function componentWillReceiveProps(nextProps /*: Object*/) {\n\t // Set x/y if position has changed\n\t if (nextProps.position && (!this.props.position || nextProps.position.x !== this.props.position.x || nextProps.position.y !== this.props.position.y)) {\n\t this.setState({ x: nextProps.position.x, y: nextProps.position.y });\n\t }\n\t }\n\t }, {\n\t key: 'componentWillUnmount',\n\t value: function componentWillUnmount() {\n\t this.setState({ dragging: false }); // prevents invariant if unmounted while dragging\n\t }\n\t }, {\n\t key: 'render',\n\t value: function render() /*: React.Element*/ {\n\t var _classNames;\n\t\n\t var style = {},\n\t svgTransform = null;\n\t\n\t // If this is controlled, we don't want to move it - unless it's dragging.\n\t var controlled = Boolean(this.props.position);\n\t var draggable = !controlled || this.state.dragging;\n\t\n\t var position = this.props.position || this.props.defaultPosition;\n\t var transformOpts = {\n\t // Set left if horizontal drag is enabled\n\t x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : position.x,\n\t\n\t // Set top if vertical drag is enabled\n\t y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : position.y\n\t };\n\t\n\t // If this element was SVG, we use the `transform` attribute.\n\t if (this.state.isElementSVG) {\n\t svgTransform = (0, _domFns.createSVGTransform)(transformOpts);\n\t } else {\n\t // Add a CSS transform to move the element around. This allows us to move the element around\n\t // without worrying about whether or not it is relatively or absolutely positioned.\n\t // If the item you are dragging already has a transform set, wrap it in a so \n\t // has a clean slate.\n\t style = (0, _domFns.createCSSTransform)(transformOpts);\n\t }\n\t\n\t var _props = this.props,\n\t defaultClassName = _props.defaultClassName,\n\t defaultClassNameDragging = _props.defaultClassNameDragging,\n\t defaultClassNameDragged = _props.defaultClassNameDragged;\n\t\n\t // Mark with class while dragging\n\t\n\t var className = (0, _classnames2.default)(this.props.children.props.className || '', defaultClassName, (_classNames = {}, _defineProperty(_classNames, defaultClassNameDragging, this.state.dragging), _defineProperty(_classNames, defaultClassNameDragged, this.state.dragged), _classNames));\n\t\n\t // Reuse the child provided\n\t // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\t return _react2.default.createElement(\n\t _DraggableCore2.default,\n\t _extends({}, this.props, { onStart: this.onDragStart, onDrag: this.onDrag, onStop: this.onDragStop }),\n\t _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n\t className: className,\n\t style: _extends({}, this.props.children.props.style, style),\n\t transform: svgTransform\n\t })\n\t );\n\t }\n\t }]);\n\t\n\t return Draggable;\n\t}(_react2.default.Component);\n\t\n\tDraggable.displayName = 'Draggable';\n\tDraggable.propTypes = _extends({}, _DraggableCore2.default.propTypes, {\n\t\n\t /**\n\t * `axis` determines which axis the draggable can move.\n\t *\n\t * Note that all callbacks will still return data as normal. This only\n\t * controls flushing to the DOM.\n\t *\n\t * 'both' allows movement horizontally and vertically.\n\t * 'x' limits movement to horizontal axis.\n\t * 'y' limits movement to vertical axis.\n\t * 'none' limits all movement.\n\t *\n\t * Defaults to 'both'.\n\t */\n\t axis: _react.PropTypes.oneOf(['both', 'x', 'y', 'none']),\n\t\n\t /**\n\t * `bounds` determines the range of movement available to the element.\n\t * Available values are:\n\t *\n\t * 'parent' restricts movement within the Draggable's parent node.\n\t *\n\t * Alternatively, pass an object with the following properties, all of which are optional:\n\t *\n\t * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n\t *\n\t * All values are in px.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
Content
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t bounds: _react.PropTypes.oneOfType([_react.PropTypes.shape({\n\t left: _react.PropTypes.number,\n\t right: _react.PropTypes.number,\n\t top: _react.PropTypes.number,\n\t bottom: _react.PropTypes.number\n\t }), _react.PropTypes.string, _react.PropTypes.oneOf([false])]),\n\t\n\t defaultClassName: _react.PropTypes.string,\n\t defaultClassNameDragging: _react.PropTypes.string,\n\t defaultClassNameDragged: _react.PropTypes.string,\n\t\n\t /**\n\t * `defaultPosition` specifies the x and y that the dragged item should start at\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
I start with transformX: 25px and transformY: 25px;
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t defaultPosition: _react.PropTypes.shape({\n\t x: _react.PropTypes.number,\n\t y: _react.PropTypes.number\n\t }),\n\t\n\t /**\n\t * `position`, if present, defines the current position of the element.\n\t *\n\t * This is similar to how form elements in React work - if no `position` is supplied, the component\n\t * is uncontrolled.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
I start with transformX: 25px and transformY: 25px;
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t position: _react.PropTypes.shape({\n\t x: _react.PropTypes.number,\n\t y: _react.PropTypes.number\n\t }),\n\t\n\t /**\n\t * These properties should be defined on the child, not here.\n\t */\n\t className: _shims.dontSetMe,\n\t style: _shims.dontSetMe,\n\t transform: _shims.dontSetMe\n\t});\n\tDraggable.defaultProps = _extends({}, _DraggableCore2.default.defaultProps, {\n\t axis: 'both',\n\t bounds: false,\n\t defaultClassName: 'react-draggable',\n\t defaultClassNameDragging: 'react-draggable-dragging',\n\t defaultClassNameDragged: 'react-draggable-dragged',\n\t defaultPosition: { x: 0, y: 0 },\n\t position: null\n\t});\n\texports.default = Draggable;\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_3__;\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n\t Copyright (c) 2016 Jed Watson.\n\t Licensed under the MIT License (MIT), see\n\t http://jedwatson.github.io/classnames\n\t*/\n\t/* global define */\n\t\n\t(function () {\n\t\t'use strict';\n\t\n\t\tvar hasOwn = {}.hasOwnProperty;\n\t\n\t\tfunction classNames () {\n\t\t\tvar classes = [];\n\t\n\t\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\t\tvar arg = arguments[i];\n\t\t\t\tif (!arg) continue;\n\t\n\t\t\t\tvar argType = typeof arg;\n\t\n\t\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\t\tclasses.push(arg);\n\t\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t\t} else if (argType === 'object') {\n\t\t\t\t\tfor (var key in arg) {\n\t\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn classes.join(' ');\n\t\t}\n\t\n\t\tif (typeof module !== 'undefined' && module.exports) {\n\t\t\tmodule.exports = classNames;\n\t\t} else if (true) {\n\t\t\t// register as 'classnames', consistent with npm package name\n\t\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\t\t\treturn classNames;\n\t\t\t}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t} else {\n\t\t\twindow.classNames = classNames;\n\t\t}\n\t}());\n\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _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; };\n\t\n\texports.matchesSelector = matchesSelector;\n\texports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\n\texports.addEvent = addEvent;\n\texports.removeEvent = removeEvent;\n\texports.outerHeight = outerHeight;\n\texports.outerWidth = outerWidth;\n\texports.innerHeight = innerHeight;\n\texports.innerWidth = innerWidth;\n\texports.offsetXYFromParent = offsetXYFromParent;\n\texports.createCSSTransform = createCSSTransform;\n\texports.createSVGTransform = createSVGTransform;\n\texports.getTouch = getTouch;\n\texports.getTouchIdentifier = getTouchIdentifier;\n\texports.addUserSelectStyles = addUserSelectStyles;\n\texports.removeUserSelectStyles = removeUserSelectStyles;\n\texports.styleHacks = styleHacks;\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _getPrefix = __webpack_require__(7);\n\t\n\tvar _getPrefix2 = _interopRequireDefault(_getPrefix);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _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\t\n\t/*:: import type {ControlPosition} from './types';*/\n\t\n\t\n\tvar matchesSelectorFunc = '';\n\tfunction matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/ {\n\t if (!matchesSelectorFunc) {\n\t matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t return (0, _shims.isFunction)(el[method]);\n\t });\n\t }\n\t\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t return el[matchesSelectorFunc].call(el, selector);\n\t}\n\t\n\t// Works up the tree to the draggable itself attempting to match selector.\n\tfunction matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/ {\n\t var node = el;\n\t do {\n\t if (matchesSelector(node, selector)) return true;\n\t if (node === baseNode) return false;\n\t node = node.parentNode;\n\t } while (node);\n\t\n\t return false;\n\t}\n\t\n\tfunction addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n\t if (!el) {\n\t return;\n\t }\n\t if (el.attachEvent) {\n\t el.attachEvent('on' + event, handler);\n\t } else if (el.addEventListener) {\n\t el.addEventListener(event, handler, true);\n\t } else {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t el['on' + event] = handler;\n\t }\n\t}\n\t\n\tfunction removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n\t if (!el) {\n\t return;\n\t }\n\t if (el.detachEvent) {\n\t el.detachEvent('on' + event, handler);\n\t } else if (el.removeEventListener) {\n\t el.removeEventListener(event, handler, true);\n\t } else {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t el['on' + event] = null;\n\t }\n\t}\n\t\n\tfunction outerHeight(node /*: HTMLElement*/) /*: number*/ {\n\t // This is deliberately excluding margin for our calculations, since we are using\n\t // offsetTop which is including margin. See getBoundPosition\n\t var height = node.clientHeight;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t height += (0, _shims.int)(computedStyle.borderTopWidth);\n\t height += (0, _shims.int)(computedStyle.borderBottomWidth);\n\t return height;\n\t}\n\t\n\tfunction outerWidth(node /*: HTMLElement*/) /*: number*/ {\n\t // This is deliberately excluding margin for our calculations, since we are using\n\t // offsetLeft which is including margin. See getBoundPosition\n\t var width = node.clientWidth;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t width += (0, _shims.int)(computedStyle.borderLeftWidth);\n\t width += (0, _shims.int)(computedStyle.borderRightWidth);\n\t return width;\n\t}\n\tfunction innerHeight(node /*: HTMLElement*/) /*: number*/ {\n\t var height = node.clientHeight;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t height -= (0, _shims.int)(computedStyle.paddingTop);\n\t height -= (0, _shims.int)(computedStyle.paddingBottom);\n\t return height;\n\t}\n\t\n\tfunction innerWidth(node /*: HTMLElement*/) /*: number*/ {\n\t var width = node.clientWidth;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t width -= (0, _shims.int)(computedStyle.paddingLeft);\n\t width -= (0, _shims.int)(computedStyle.paddingRight);\n\t return width;\n\t}\n\t\n\t// Get from offsetParent\n\tfunction offsetXYFromParent(evt /*: {clientX: number, clientY: number}*/, offsetParent /*: HTMLElement*/) /*: ControlPosition*/ {\n\t var isBody = offsetParent === offsetParent.ownerDocument.body;\n\t var offsetParentRect = isBody ? { left: 0, top: 0 } : offsetParent.getBoundingClientRect();\n\t\n\t var x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;\n\t var y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;\n\t\n\t return { x: x, y: y };\n\t}\n\t\n\tfunction createCSSTransform(_ref) /*: Object*/ {\n\t var x = _ref.x,\n\t y = _ref.y;\n\t\n\t // Replace unitless items with px\n\t return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix2.default), 'translate(' + x + 'px,' + y + 'px)');\n\t}\n\t\n\tfunction createSVGTransform(_ref3) /*: string*/ {\n\t var x = _ref3.x,\n\t y = _ref3.y;\n\t\n\t return 'translate(' + x + ',' + y + ')';\n\t}\n\t\n\tfunction getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/ {\n\t return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n\t return identifier === t.identifier;\n\t }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n\t return identifier === t.identifier;\n\t });\n\t}\n\t\n\tfunction getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/ {\n\t if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n\t if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n\t}\n\t\n\t// User-select Hacks:\n\t//\n\t// Useful for preventing blue highlights all over everything when dragging.\n\tvar userSelectPrefix = (0, _getPrefix.getPrefix)('user-select');\n\tvar userSelect = (0, _getPrefix.browserPrefixToStyle)('user-select', userSelectPrefix);\n\tvar userSelectStyle = ';' + userSelect + ': none;';\n\tvar userSelectReplaceRegExp = new RegExp(';?' + userSelect + ': none;'); // leading ; not present on IE\n\t\n\t// Note we're passing `document` b/c we could be iframed\n\tfunction addUserSelectStyles(body /*: HTMLElement*/) {\n\t var style = body.getAttribute('style') || '';\n\t body.setAttribute('style', style + userSelectStyle);\n\t}\n\t\n\tfunction removeUserSelectStyles(body /*: HTMLElement*/) {\n\t var style = body.getAttribute('style') || '';\n\t body.setAttribute('style', style.replace(userSelectReplaceRegExp, ''));\n\t}\n\t\n\tfunction styleHacks() /*: Object*/ {\n\t var childStyle /*: Object*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\t\n\t // Workaround IE pointer events; see #51\n\t // https://github.com/mzabriskie/react-draggable/issues/51#issuecomment-103488278\n\t return _extends({\n\t touchAction: 'none'\n\t }, childStyle);\n\t}\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.findInArray = findInArray;\n\texports.isFunction = isFunction;\n\texports.isNum = isNum;\n\texports.int = int;\n\texports.dontSetMe = dontSetMe;\n\t\n\t// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\n\tfunction findInArray(array /*: Array | TouchList*/, callback /*: Function*/) /*: any*/ {\n\t for (var i = 0, length = array.length; i < length; i++) {\n\t if (callback.apply(callback, [array[i], i, array])) return array[i];\n\t }\n\t}\n\t\n\tfunction isFunction(func /*: any*/) /*: boolean*/ {\n\t return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n\t}\n\t\n\tfunction isNum(num /*: any*/) /*: boolean*/ {\n\t return typeof num === 'number' && !isNaN(num);\n\t}\n\t\n\tfunction int(a /*: string*/) /*: number*/ {\n\t return parseInt(a, 10);\n\t}\n\t\n\tfunction dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) {\n\t if (props[propName]) {\n\t return new Error('Invalid prop ' + propName + ' passed to ' + componentName + ' - do not set this, set it on the child.');\n\t }\n\t}\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.getPrefix = getPrefix;\n\texports.browserPrefixToKey = browserPrefixToKey;\n\texports.browserPrefixToStyle = browserPrefixToStyle;\n\tvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\n\tfunction getPrefix() /*: string*/ {\n\t var prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n\t\n\t // Checking specifically for 'window.document' is for pseudo-browser server-side\n\t // environments that define 'window' as the global context.\n\t // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n\t if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n\t\n\t var style = window.document.documentElement.style;\n\t\n\t if (prop in style) return '';\n\t\n\t for (var i = 0; i < prefixes.length; i++) {\n\t if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n\t }\n\t\n\t return '';\n\t}\n\t\n\tfunction browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n\t return prefix ? '' + prefix + kebabToTitleCase(prop) : prop;\n\t}\n\t\n\tfunction browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n\t return prefix ? '-' + prefix.toLowerCase() + '-' + prop : prop;\n\t}\n\t\n\tfunction kebabToTitleCase(str /*: string*/) /*: string*/ {\n\t var out = '';\n\t var shouldCapitalize = true;\n\t for (var i = 0; i < str.length; i++) {\n\t if (shouldCapitalize) {\n\t out += str[i].toUpperCase();\n\t shouldCapitalize = false;\n\t } else if (str[i] === '-') {\n\t shouldCapitalize = true;\n\t } else {\n\t out += str[i];\n\t }\n\t }\n\t return out;\n\t}\n\t\n\t// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n\t// Note that you may have to re-test for certain things; for instance, Chrome 50\n\t// can handle unprefixed `transform`, but not unprefixed `user-select`\n\texports.default = getPrefix();\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.getBoundPosition = getBoundPosition;\n\texports.snapToGrid = snapToGrid;\n\texports.canDragX = canDragX;\n\texports.canDragY = canDragY;\n\texports.getControlPosition = getControlPosition;\n\texports.createCoreData = createCoreData;\n\texports.createDraggableData = createDraggableData;\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\t/*:: import type Draggable from '../Draggable';*/\n\t/*:: import type {Bounds, ControlPosition, DraggableData} from './types';*/\n\t/*:: import type DraggableCore from '../DraggableCore';*/\n\tfunction getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/ {\n\t // If no bounds, short-circuit and move on\n\t if (!draggable.props.bounds) return [x, y];\n\t\n\t // Clone new bounds\n\t var bounds = draggable.props.bounds;\n\t\n\t bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n\t var node = _reactDom2.default.findDOMNode(draggable);\n\t\n\t if (typeof bounds === 'string') {\n\t var ownerDocument = node.ownerDocument;\n\t\n\t var ownerWindow = ownerDocument.defaultView;\n\t var boundNode = void 0;\n\t if (bounds === 'parent') {\n\t boundNode = node.parentNode;\n\t } else {\n\t boundNode = ownerDocument.querySelector(bounds);\n\t if (!boundNode) throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n\t }\n\t var nodeStyle = ownerWindow.getComputedStyle(node);\n\t var boundNodeStyle = ownerWindow.getComputedStyle(boundNode);\n\t // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n\t bounds = {\n\t left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.borderLeftWidth) + (0, _shims.int)(nodeStyle.marginLeft),\n\t top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.borderTopWidth) + (0, _shims.int)(nodeStyle.marginTop),\n\t right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft,\n\t bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop\n\t };\n\t }\n\t\n\t // Keep x and y below right and bottom limits...\n\t if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n\t if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\t\n\t // But above left and top limits.\n\t if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n\t if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n\t\n\t return [x, y];\n\t}\n\t\n\tfunction snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/ {\n\t var x = Math.round(pendingX / grid[0]) * grid[0];\n\t var y = Math.round(pendingY / grid[1]) * grid[1];\n\t return [x, y];\n\t}\n\t\n\tfunction canDragX(draggable /*: Draggable*/) /*: boolean*/ {\n\t return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n\t}\n\t\n\tfunction canDragY(draggable /*: Draggable*/) /*: boolean*/ {\n\t return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n\t}\n\t\n\t// Get {x, y} positions from event.\n\tfunction getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/ {\n\t var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n\t if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n\t var node = _reactDom2.default.findDOMNode(draggableCore);\n\t // User can provide an offsetParent if desired.\n\t var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n\t return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent);\n\t}\n\t\n\t// Create an data object exposed by 's events\n\tfunction createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/ {\n\t var state = draggable.state;\n\t var isStart = !(0, _shims.isNum)(state.lastX);\n\t\n\t if (isStart) {\n\t // If this is our first move, use the x and y as last coords.\n\t return {\n\t node: _reactDom2.default.findDOMNode(draggable),\n\t deltaX: 0, deltaY: 0,\n\t lastX: x, lastY: y,\n\t x: x, y: y\n\t };\n\t } else {\n\t // Otherwise calculate proper values.\n\t return {\n\t node: _reactDom2.default.findDOMNode(draggable),\n\t deltaX: x - state.lastX, deltaY: y - state.lastY,\n\t lastX: state.lastX, lastY: state.lastY,\n\t x: x, y: y\n\t };\n\t }\n\t}\n\t\n\t// Create an data exposed by 's events\n\tfunction createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/ {\n\t return {\n\t node: coreData.node,\n\t x: draggable.state.x + coreData.deltaX,\n\t y: draggable.state.y + coreData.deltaY,\n\t deltaX: coreData.deltaX,\n\t deltaY: coreData.deltaY,\n\t lastX: draggable.state.x,\n\t lastY: draggable.state.y\n\t };\n\t}\n\t\n\t// A lot faster than stringify/parse\n\tfunction cloneBounds(bounds /*: Bounds*/) /*: Bounds*/ {\n\t return {\n\t left: bounds.left,\n\t top: bounds.top,\n\t right: bounds.right,\n\t bottom: bounds.bottom\n\t };\n\t}\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_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\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\t\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _react = __webpack_require__(2);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tvar _positionFns = __webpack_require__(8);\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _log = __webpack_require__(11);\n\t\n\tvar _log2 = _interopRequireDefault(_log);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\t// Simple abstraction for dragging events names.\n\t/*:: import type {EventHandler} from './utils/types';*/\n\tvar eventsFor = {\n\t touch: {\n\t start: 'touchstart',\n\t move: 'touchmove',\n\t stop: 'touchend'\n\t },\n\t mouse: {\n\t start: 'mousedown',\n\t move: 'mousemove',\n\t stop: 'mouseup'\n\t }\n\t};\n\t\n\t// Default to mouse events.\n\tvar dragEventFor = eventsFor.mouse;\n\t\n\t//\n\t// Define .\n\t//\n\t// is for advanced usage of . It maintains minimal internal state so it can\n\t// work well with libraries that require more control over the element.\n\t//\n\t\n\t/*:: type CoreState = {\n\t dragging: boolean,\n\t lastX: number,\n\t lastY: number,\n\t touchIdentifier: ?number\n\t};*/\n\t\n\tvar DraggableCore = function (_React$Component) {\n\t _inherits(DraggableCore, _React$Component);\n\t\n\t function DraggableCore() {\n\t var _ref;\n\t\n\t var _temp, _this, _ret;\n\t\n\t _classCallCheck(this, DraggableCore);\n\t\n\t for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n\t args[_key] = arguments[_key];\n\t }\n\t\n\t return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = DraggableCore.__proto__ || Object.getPrototypeOf(DraggableCore)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n\t dragging: false,\n\t // Used while dragging to determine deltas.\n\t lastX: NaN, lastY: NaN,\n\t touchIdentifier: null\n\t }, _this.handleDragStart = function (e) {\n\t // Make it possible to attach event handlers on top of this one.\n\t _this.props.onMouseDown(e);\n\t\n\t // Only accept left-clicks.\n\t if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\t\n\t // Get nodes. Be sure to grab relative document (could be iframed)\n\t var domNode = _reactDom2.default.findDOMNode(_this);\n\t var ownerDocument = domNode.ownerDocument;\n\t\n\t // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\t\n\t if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, domNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, domNode)) {\n\t return;\n\t }\n\t\n\t // Set touch identifier in component state if this is a touch event. This allows us to\n\t // distinguish between individual touches on multitouch screens by identifying which\n\t // touchpoint was set to this element.\n\t var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n\t _this.setState({ touchIdentifier: touchIdentifier });\n\t\n\t // Get the current drag point from the event. This is used as the offset.\n\t var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _this);\n\t if (position == null) return; // not possible but satisfies flow\n\t var x = position.x,\n\t y = position.y;\n\t\n\t // Create an event object with all the data parents need to make a decision here.\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t (0, _log2.default)('DraggableCore: handleDragStart: %j', coreEvent);\n\t\n\t // Call event handler. If it returns explicit false, cancel.\n\t (0, _log2.default)('calling', _this.props.onStart);\n\t var shouldUpdate = _this.props.onStart(e, coreEvent);\n\t if (shouldUpdate === false) return;\n\t\n\t // Add a style to the body to disable user-select. This prevents text from\n\t // being selected all over the page.\n\t if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument.body);\n\t\n\t // Initiate dragging. Set the current x and y as offsets\n\t // so we know how much we've moved during the drag. This allows us\n\t // to drag elements around even if they have been moved, without issue.\n\t _this.setState({\n\t dragging: true,\n\t\n\t lastX: x,\n\t lastY: y\n\t });\n\t\n\t // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n\t // this element. We use different events depending on whether or not we have detected that this\n\t // is a touch-capable device.\n\t (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n\t (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n\t }, _this.handleDrag = function (e) {\n\t\n\t // Prevent scrolling on mobile devices, like ipad/iphone.\n\t if (e.type === 'touchmove') e.preventDefault();\n\t\n\t // Get the current drag point from the event. This is used as the offset.\n\t var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n\t if (position == null) return;\n\t var x = position.x,\n\t y = position.y;\n\t\n\t // Snap to grid if prop has been provided\n\t\n\t if (x !== x) debugger;\n\t\n\t if (Array.isArray(_this.props.grid)) {\n\t var deltaX = x - _this.state.lastX,\n\t deltaY = y - _this.state.lastY;\n\t\n\t var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);\n\t\n\t var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\t\n\t deltaX = _snapToGrid2[0];\n\t deltaY = _snapToGrid2[1];\n\t\n\t if (!deltaX && !deltaY) return; // skip useless drag\n\t x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;\n\t }\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t (0, _log2.default)('DraggableCore: handleDrag: %j', coreEvent);\n\t\n\t // Call event handler. If it returns explicit false, trigger end.\n\t var shouldUpdate = _this.props.onDrag(e, coreEvent);\n\t if (shouldUpdate === false) {\n\t try {\n\t // $FlowIgnore\n\t _this.handleDragStop(new MouseEvent('mouseup'));\n\t } catch (err) {\n\t // Old browsers\n\t var event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);\n\t // I see why this insanity was deprecated\n\t // $FlowIgnore\n\t event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n\t _this.handleDragStop(event);\n\t }\n\t return;\n\t }\n\t\n\t _this.setState({\n\t lastX: x,\n\t lastY: y\n\t });\n\t }, _this.handleDragStop = function (e) {\n\t if (!_this.state.dragging) return;\n\t\n\t var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n\t if (position == null) return;\n\t var x = position.x,\n\t y = position.y;\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t var _ReactDOM$findDOMNode = _reactDom2.default.findDOMNode(_this),\n\t ownerDocument = _ReactDOM$findDOMNode.ownerDocument;\n\t\n\t // Remove user-select hack\n\t\n\t\n\t if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument.body);\n\t\n\t (0, _log2.default)('DraggableCore: handleDragStop: %j', coreEvent);\n\t\n\t // Reset the el.\n\t _this.setState({\n\t dragging: false,\n\t lastX: NaN,\n\t lastY: NaN\n\t });\n\t\n\t // Call event handler\n\t _this.props.onStop(e, coreEvent);\n\t\n\t // Remove event handlers\n\t (0, _log2.default)('DraggableCore: Removing handlers');\n\t (0, _domFns.removeEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n\t }, _this.onMouseDown = function (e) {\n\t dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\t\n\t return _this.handleDragStart(e);\n\t }, _this.onMouseUp = function (e) {\n\t dragEventFor = eventsFor.mouse;\n\t\n\t return _this.handleDragStop(e);\n\t }, _this.onTouchStart = function (e) {\n\t // We're on a touch device now, so change the event handlers\n\t dragEventFor = eventsFor.touch;\n\t\n\t return _this.handleDragStart(e);\n\t }, _this.onTouchEnd = function (e) {\n\t // We're on a touch device now, so change the event handlers\n\t dragEventFor = eventsFor.touch;\n\t\n\t return _this.handleDragStop(e);\n\t }, _temp), _possibleConstructorReturn(_this, _ret);\n\t }\n\t\n\t _createClass(DraggableCore, [{\n\t key: 'componentWillUnmount',\n\t value: function componentWillUnmount() {\n\t // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n\t // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n\t var _ReactDOM$findDOMNode2 = _reactDom2.default.findDOMNode(this),\n\t ownerDocument = _ReactDOM$findDOMNode2.ownerDocument;\n\t\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n\t if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument.body);\n\t }\n\t\n\t // Same as onMouseDown (start drag), but now consider this a touch device.\n\t\n\t }, {\n\t key: 'render',\n\t value: function render() /*: React.Element*/ {\n\t // Reuse the child provided\n\t // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\t return _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n\t style: (0, _domFns.styleHacks)(this.props.children.props.style),\n\t\n\t // Note: mouseMove handler is attached to document so it will still function\n\t // when the user drags quickly and leaves the bounds of the element.\n\t onMouseDown: this.onMouseDown,\n\t onTouchStart: this.onTouchStart,\n\t onMouseUp: this.onMouseUp,\n\t onTouchEnd: this.onTouchEnd\n\t });\n\t }\n\t }]);\n\t\n\t return DraggableCore;\n\t}(_react2.default.Component);\n\t\n\tDraggableCore.displayName = 'DraggableCore';\n\tDraggableCore.propTypes = {\n\t /**\n\t * `allowAnyClick` allows dragging using any mouse button.\n\t * By default, we only accept the left button.\n\t *\n\t * Defaults to `false`.\n\t */\n\t allowAnyClick: _react.PropTypes.bool,\n\t\n\t /**\n\t * `disabled`, if true, stops the from dragging. All handlers,\n\t * with the exception of `onMouseDown`, will not fire.\n\t */\n\t disabled: _react.PropTypes.bool,\n\t\n\t /**\n\t * By default, we add 'user-select:none' attributes to the document body\n\t * to prevent ugly text selection during drag. If this is causing problems\n\t * for your app, set this to `false`.\n\t */\n\t enableUserSelectHack: _react.PropTypes.bool,\n\t\n\t /**\n\t * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n\t * instead of using the parent node.\n\t */\n\t offsetParent: function offsetParent(props, propName) {\n\t if (process.browser && props[propName] && props[propName].nodeType !== 1) {\n\t throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n\t }\n\t },\n\t\n\t /**\n\t * `grid` specifies the x and y that dragging should snap to.\n\t */\n\t grid: _react.PropTypes.arrayOf(_react.PropTypes.number),\n\t\n\t /**\n\t * `handle` specifies a selector to be used as the handle that initiates drag.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
\n\t *
Click me to drag
\n\t *
This is some other content
\n\t *
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t handle: _react.PropTypes.string,\n\t\n\t /**\n\t * `cancel` specifies a selector to be used to prevent drag initialization.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return(\n\t * \n\t *
\n\t *
You can't drag from here
\n\t *
Dragging here works fine
\n\t *
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t cancel: _react.PropTypes.string,\n\t\n\t /**\n\t * Called when dragging starts.\n\t * If this function returns the boolean false, dragging will be canceled.\n\t */\n\t onStart: _react.PropTypes.func,\n\t\n\t /**\n\t * Called while dragging.\n\t * If this function returns the boolean false, dragging will be canceled.\n\t */\n\t onDrag: _react.PropTypes.func,\n\t\n\t /**\n\t * Called when dragging stops.\n\t * If this function returns the boolean false, the drag will remain active.\n\t */\n\t onStop: _react.PropTypes.func,\n\t\n\t /**\n\t * A workaround option which can be passed if onMouseDown needs to be accessed,\n\t * since it'll always be blocked (as there is internal use of onMouseDown)\n\t */\n\t onMouseDown: _react.PropTypes.func,\n\t\n\t /**\n\t * These properties should be defined on the child, not here.\n\t */\n\t className: _shims.dontSetMe,\n\t style: _shims.dontSetMe,\n\t transform: _shims.dontSetMe\n\t};\n\tDraggableCore.defaultProps = {\n\t allowAnyClick: false, // by default only accept left click\n\t cancel: null,\n\t disabled: false,\n\t enableUserSelectHack: true,\n\t offsetParent: null,\n\t handle: null,\n\t grid: null,\n\t transform: null,\n\t onStart: function onStart() {},\n\t onDrag: function onDrag() {},\n\t onStop: function onStop() {},\n\t onMouseDown: function onMouseDown() {}\n\t};\n\texports.default = DraggableCore;\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10)))\n\n/***/ },\n/* 10 */\n/***/ function(module, exports) {\n\n\t// shim for using process in browser\n\tvar process = module.exports = {};\n\t\n\t// cached from whatever global is present so that test runners that stub it\n\t// don't break things. But we need to wrap it in a try catch in case it is\n\t// wrapped in strict mode code which doesn't define any globals. It's inside a\n\t// function because try/catches deoptimize in certain engines.\n\t\n\tvar cachedSetTimeout;\n\tvar cachedClearTimeout;\n\t\n\tfunction defaultSetTimout() {\n\t throw new Error('setTimeout has not been defined');\n\t}\n\tfunction defaultClearTimeout () {\n\t throw new Error('clearTimeout has not been defined');\n\t}\n\t(function () {\n\t try {\n\t if (typeof setTimeout === 'function') {\n\t cachedSetTimeout = setTimeout;\n\t } else {\n\t cachedSetTimeout = defaultSetTimout;\n\t }\n\t } catch (e) {\n\t cachedSetTimeout = defaultSetTimout;\n\t }\n\t try {\n\t if (typeof clearTimeout === 'function') {\n\t cachedClearTimeout = clearTimeout;\n\t } else {\n\t cachedClearTimeout = defaultClearTimeout;\n\t }\n\t } catch (e) {\n\t cachedClearTimeout = defaultClearTimeout;\n\t }\n\t} ())\n\tfunction runTimeout(fun) {\n\t if (cachedSetTimeout === setTimeout) {\n\t //normal enviroments in sane situations\n\t return setTimeout(fun, 0);\n\t }\n\t // if setTimeout wasn't available but was latter defined\n\t if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t cachedSetTimeout = setTimeout;\n\t return setTimeout(fun, 0);\n\t }\n\t try {\n\t // when when somebody has screwed with setTimeout but no I.E. maddness\n\t return cachedSetTimeout(fun, 0);\n\t } catch(e){\n\t try {\n\t // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t return cachedSetTimeout.call(null, fun, 0);\n\t } catch(e){\n\t // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n\t return cachedSetTimeout.call(this, fun, 0);\n\t }\n\t }\n\t\n\t\n\t}\n\tfunction runClearTimeout(marker) {\n\t if (cachedClearTimeout === clearTimeout) {\n\t //normal enviroments in sane situations\n\t return clearTimeout(marker);\n\t }\n\t // if clearTimeout wasn't available but was latter defined\n\t if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t cachedClearTimeout = clearTimeout;\n\t return clearTimeout(marker);\n\t }\n\t try {\n\t // when when somebody has screwed with setTimeout but no I.E. maddness\n\t return cachedClearTimeout(marker);\n\t } catch (e){\n\t try {\n\t // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t return cachedClearTimeout.call(null, marker);\n\t } catch (e){\n\t // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n\t // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t return cachedClearTimeout.call(this, marker);\n\t }\n\t }\n\t\n\t\n\t\n\t}\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\t\n\tfunction cleanUpNextTick() {\n\t if (!draining || !currentQueue) {\n\t return;\n\t }\n\t draining = false;\n\t if (currentQueue.length) {\n\t queue = currentQueue.concat(queue);\n\t } else {\n\t queueIndex = -1;\n\t }\n\t if (queue.length) {\n\t drainQueue();\n\t }\n\t}\n\t\n\tfunction drainQueue() {\n\t if (draining) {\n\t return;\n\t }\n\t var timeout = runTimeout(cleanUpNextTick);\n\t draining = true;\n\t\n\t var len = queue.length;\n\t while(len) {\n\t currentQueue = queue;\n\t queue = [];\n\t while (++queueIndex < len) {\n\t if (currentQueue) {\n\t currentQueue[queueIndex].run();\n\t }\n\t }\n\t queueIndex = -1;\n\t len = queue.length;\n\t }\n\t currentQueue = null;\n\t draining = false;\n\t runClearTimeout(timeout);\n\t}\n\t\n\tprocess.nextTick = function (fun) {\n\t var args = new Array(arguments.length - 1);\n\t if (arguments.length > 1) {\n\t for (var i = 1; i < arguments.length; i++) {\n\t args[i - 1] = arguments[i];\n\t }\n\t }\n\t queue.push(new Item(fun, args));\n\t if (queue.length === 1 && !draining) {\n\t runTimeout(drainQueue);\n\t }\n\t};\n\t\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t this.fun = fun;\n\t this.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t this.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\t\n\tfunction noop() {}\n\t\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\t\n\tprocess.binding = function (name) {\n\t throw new Error('process.binding is not supported');\n\t};\n\t\n\tprocess.cwd = function () { return '/' };\n\tprocess.chdir = function (dir) {\n\t throw new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function() { return 0; };\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.default = log;\n\t\n\t/*eslint no-console:0*/\n\tfunction log() {\n\t var _console;\n\t\n\t if ((undefined)) (_console = console).log.apply(_console, arguments);\n\t}\n\n/***/ }\n/******/ ])\n});\n;\n//# sourceMappingURL=react-draggable.js.map\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDraggable = __webpack_require__(7);\n\nvar _cloneElement = __webpack_require__(17);\n\nvar _cloneElement2 = _interopRequireDefault(_cloneElement);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/*:: export type Props = {\n children: React.Element,\n width: number,\n height: number,\n handleSize: [number, number],\n lockAspectRatio: boolean,\n axis: Axis,\n minConstraints: [number, number],\n maxConstraints: [number, number],\n onResizeStop?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n onResizeStart?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n onResize?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n draggableOpts?: ?Object\n};*/\n/*:: type Axis = 'both' | 'x' | 'y' | 'none';*/\n/*:: type Position = {\n\n};*/\n/*:: type State = {\n resizing: boolean,\n width: number, height: number,\n slackW: number, slackH: number\n};*/\n/*:: type DragCallbackData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number\n};*/\n/*:: type ResizeCallbackData = {\n node: HTMLElement,\n size: {width: number, height: number}\n};*/\n\nvar Resizable = function (_React$Component) {\n _inherits(Resizable, _React$Component);\n\n function Resizable() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, Resizable);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n resizing: false,\n width: _this.props.width, height: _this.props.height,\n slackW: 0, slackH: 0\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n Resizable.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps /*: Object*/) {\n // If parent changes height/width, set that in our state.\n if (!this.state.resizing && (nextProps.width !== this.props.width || nextProps.height !== this.props.height)) {\n this.setState({\n width: nextProps.width,\n height: nextProps.height\n });\n }\n };\n\n Resizable.prototype.lockAspectRatio = function lockAspectRatio(width /*: number*/, height /*: number*/, aspectRatio /*: number*/) /*: [number, number]*/ {\n height = width / aspectRatio;\n width = height * aspectRatio;\n return [width, height];\n };\n\n // If you do this, be careful of constraints\n\n\n Resizable.prototype.runConstraints = function runConstraints(width /*: number*/, height /*: number*/) /*: [number, number]*/ {\n var _ref = [this.props.minConstraints, this.props.maxConstraints],\n min = _ref[0],\n max = _ref[1];\n\n\n if (this.props.lockAspectRatio) {\n var ratio = this.state.width / this.state.height;\n height = width / ratio;\n width = height * ratio;\n }\n\n if (!min && !max) return [width, height];\n\n var oldW = width,\n oldH = height;\n\n // 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 _state = this.state,\n slackW = _state.slackW,\n slackH = _state.slackH;\n\n width += slackW;\n height += slackH;\n\n if (min) {\n width = Math.max(min[0], width);\n height = Math.max(min[1], height);\n }\n if (max) {\n width = Math.min(max[0], width);\n height = Math.min(max[1], height);\n }\n\n // If the numbers changed, we must have introduced some slack. Record it for the next iteration.\n slackW += oldW - width;\n slackH += oldH - height;\n if (slackW !== this.state.slackW || slackH !== this.state.slackH) {\n this.setState({ slackW: slackW, slackH: slackH });\n }\n\n return [width, height];\n };\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 Resizable.prototype.resizeHandler = function resizeHandler(handlerName /*: string*/) /*: Function*/ {\n var _this2 = this;\n\n return function (e /*: SyntheticEvent | MouseEvent*/, _ref2) {\n var node = _ref2.node,\n deltaX = _ref2.deltaX,\n deltaY = _ref2.deltaY;\n\n\n // Axis restrictions\n var canDragX = _this2.props.axis === 'both' || _this2.props.axis === 'x';\n var canDragY = _this2.props.axis === 'both' || _this2.props.axis === 'y';\n\n // Update w/h\n var width = _this2.state.width + (canDragX ? deltaX : 0);\n var height = _this2.state.height + (canDragY ? deltaY : 0);\n\n // Early return if no change\n var widthChanged = width !== _this2.state.width,\n heightChanged = height !== _this2.state.height;\n if (handlerName === 'onResize' && !widthChanged && !heightChanged) return;\n\n // Set the appropriate state for this handler.\n var _runConstraints = _this2.runConstraints(width, height);\n\n width = _runConstraints[0];\n height = _runConstraints[1];\n var newState = {};\n if (handlerName === 'onResizeStart') {\n newState.resizing = true;\n } else if (handlerName === 'onResizeStop') {\n newState.resizing = false;\n newState.slackW = newState.slackH = 0;\n } else {\n // Early return if no change after constraints\n if (width === _this2.state.width && height === _this2.state.height) return;\n newState.width = width;\n newState.height = height;\n }\n\n var hasCb = typeof _this2.props[handlerName] === 'function';\n if (hasCb) {\n if (typeof e.persist === 'function') e.persist();\n _this2.setState(newState, function () {\n return _this2.props[handlerName](e, { node: node, size: { width: width, height: height } });\n });\n } else {\n _this2.setState(newState);\n }\n };\n };\n\n Resizable.prototype.render = function render() /*: React.Element*/ {\n // eslint-disable-next-line no-unused-vars\n var _props = this.props,\n children = _props.children,\n draggableOpts = _props.draggableOpts,\n width = _props.width,\n height = _props.height,\n handleSize = _props.handleSize,\n lockAspectRatio = _props.lockAspectRatio,\n axis = _props.axis,\n minConstraints = _props.minConstraints,\n maxConstraints = _props.maxConstraints,\n onResize = _props.onResize,\n onResizeStop = _props.onResizeStop,\n onResizeStart = _props.onResizeStart,\n p = _objectWithoutProperties(_props, ['children', 'draggableOpts', 'width', 'height', 'handleSize', 'lockAspectRatio', 'axis', 'minConstraints', 'maxConstraints', 'onResize', 'onResizeStop', 'onResizeStart']);\n\n var className = p.className ? p.className + ' react-resizable' : 'react-resizable';\n\n // 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 // Its original children (resizable's child's children), and\n // A draggable handle.\n return (0, _cloneElement2.default)(children, _extends({}, p, {\n className: className,\n children: [children.props.children, _react2.default.createElement(\n _reactDraggable.DraggableCore,\n _extends({}, draggableOpts, {\n key: 'resizableHandle',\n onStop: this.resizeHandler('onResizeStop'),\n onStart: this.resizeHandler('onResizeStart'),\n onDrag: this.resizeHandler('onResize')\n }),\n _react2.default.createElement('span', { className: 'react-resizable-handle' })\n )]\n }));\n };\n\n return Resizable;\n}(_react2.default.Component);\n\nResizable.propTypes = {\n //\n // Required Props\n //\n\n // Require that one and only one child be present.\n children: _react.PropTypes.element.isRequired,\n\n // Initial w/h\n width: _react.PropTypes.number.isRequired,\n height: _react.PropTypes.number.isRequired,\n\n //\n // Optional props\n //\n\n // If you change this, be sure to update your css\n handleSize: _react.PropTypes.array,\n\n // If true, will only allow width/height to move in lockstep\n lockAspectRatio: _react.PropTypes.bool,\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 axis: _react.PropTypes.oneOf(['both', 'x', 'y', 'none']),\n\n // Min/max size\n minConstraints: _react.PropTypes.arrayOf(_react.PropTypes.number),\n maxConstraints: _react.PropTypes.arrayOf(_react.PropTypes.number),\n\n // Callbacks\n onResizeStop: _react.PropTypes.func,\n onResizeStart: _react.PropTypes.func,\n onResize: _react.PropTypes.func,\n\n // These will be passed wholesale to react-draggable's DraggableCore\n draggableOpts: _react.PropTypes.object\n};\nResizable.defaultProps = {\n handleSize: [20, 20],\n lockAspectRatio: false,\n axis: 'both',\n minConstraints: [20, 20],\n maxConstraints: [Infinity, Infinity]\n};\nexports.default = Resizable;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_9__;\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(2);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _lodash = __webpack_require__(3);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nvar _utils = __webpack_require__(1);\n\nvar _responsiveUtils = __webpack_require__(5);\n\nvar _ReactGridLayout = __webpack_require__(4);\n\nvar _ReactGridLayout2 = _interopRequireDefault(_ReactGridLayout);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar noop = function noop() {};\nvar type = function type(obj) {\n return Object.prototype.toString.call(obj);\n};\n\nvar ResponsiveReactGridLayout = function (_React$Component) {\n _inherits(ResponsiveReactGridLayout, _React$Component);\n\n function ResponsiveReactGridLayout() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, ResponsiveReactGridLayout);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = _this.generateInitialState(), _this.onLayoutChange = function (layout) {\n var _extends2;\n\n _this.props.onLayoutChange(layout, _extends({}, _this.props.layouts, (_extends2 = {}, _extends2[_this.state.breakpoint] = layout, _extends2)));\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\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\n\n ResponsiveReactGridLayout.prototype.generateInitialState = function generateInitialState() {\n var _props = this.props,\n width = _props.width,\n breakpoints = _props.breakpoints,\n layouts = _props.layouts,\n verticalCompact = _props.verticalCompact,\n cols = _props.cols;\n\n var breakpoint = (0, _responsiveUtils.getBreakpointFromWidth)(breakpoints, width);\n var colNo = (0, _responsiveUtils.getColsFromBreakpoint)(breakpoint, cols);\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 var initialLayout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(layouts, breakpoints, breakpoint, breakpoint, colNo, verticalCompact);\n\n return {\n layout: initialLayout,\n breakpoint: breakpoint,\n cols: colNo\n };\n };\n\n ResponsiveReactGridLayout.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n\n // Allow parent to set width or breakpoint directly.\n if (nextProps.width != this.props.width || nextProps.breakpoint !== this.props.breakpoint || !(0, _lodash2.default)(nextProps.breakpoints, this.props.breakpoints) || !(0, _lodash2.default)(nextProps.cols, this.props.cols)) {\n this.onWidthChange(nextProps);\n }\n\n // Allow parent to set layouts directly.\n else if (!(0, _lodash2.default)(nextProps.layouts, this.props.layouts)) {\n var _state = this.state,\n _breakpoint = _state.breakpoint,\n _cols = _state.cols;\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\n var newLayout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(nextProps.layouts, nextProps.breakpoints, _breakpoint, _breakpoint, _cols, nextProps.verticalCompact);\n this.setState({ layout: newLayout });\n }\n };\n\n // wrap layouts so we do not need to pass layouts to child\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 ResponsiveReactGridLayout.prototype.onWidthChange = function onWidthChange(nextProps) {\n var breakpoints = nextProps.breakpoints,\n cols = nextProps.cols,\n layouts = nextProps.layouts,\n verticalCompact = nextProps.verticalCompact;\n\n var newBreakpoint = nextProps.breakpoint || (0, _responsiveUtils.getBreakpointFromWidth)(nextProps.breakpoints, nextProps.width);\n\n var lastBreakpoint = this.state.breakpoint;\n\n // Breakpoint change\n if (lastBreakpoint !== newBreakpoint || this.props.breakpoints !== breakpoints || this.props.cols !== cols) {\n // Preserve the current layout if the current breakpoint is not present in the next layouts.\n if (!(lastBreakpoint in layouts)) layouts[lastBreakpoint] = (0, _utils.cloneLayout)(this.state.layout);\n\n // Find or generate a new layout.\n var newCols = (0, _responsiveUtils.getColsFromBreakpoint)(newBreakpoint, cols);\n var _layout = (0, _responsiveUtils.findOrGenerateResponsiveLayout)(layouts, breakpoints, newBreakpoint, lastBreakpoint, newCols, verticalCompact);\n\n // This adds missing items.\n _layout = (0, _utils.synchronizeLayoutWithChildren)(_layout, nextProps.children, newCols, verticalCompact);\n\n // Store the new layout.\n layouts[newBreakpoint] = _layout;\n\n // callbacks\n this.props.onLayoutChange(_layout, layouts);\n this.props.onBreakpointChange(newBreakpoint, newCols);\n this.props.onWidthChange(nextProps.width, nextProps.margin, newCols, nextProps.containerPadding);\n\n this.setState({ breakpoint: newBreakpoint, layout: _layout, cols: newCols });\n }\n };\n\n ResponsiveReactGridLayout.prototype.render = function render() {\n // eslint-disable-next-line no-unused-vars\n var _props2 = this.props,\n breakpoint = _props2.breakpoint,\n breakpoints = _props2.breakpoints,\n cols = _props2.cols,\n layouts = _props2.layouts,\n onBreakpointChange = _props2.onBreakpointChange,\n onLayoutChange = _props2.onLayoutChange,\n onWidthChange = _props2.onWidthChange,\n other = _objectWithoutProperties(_props2, ['breakpoint', 'breakpoints', 'cols', 'layouts', 'onBreakpointChange', 'onLayoutChange', 'onWidthChange']);\n\n return _react2.default.createElement(_ReactGridLayout2.default, _extends({}, other, {\n onLayoutChange: this.onLayoutChange,\n layout: this.state.layout,\n cols: this.state.cols\n }));\n };\n\n return ResponsiveReactGridLayout;\n}(_react2.default.Component);\n\nResponsiveReactGridLayout.propTypes = {\n\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: _propTypes2.default.string,\n\n // {name: pxVal}, e.g. {lg: 1200, md: 996, sm: 768, xs: 480}\n breakpoints: _propTypes2.default.object,\n\n // # of cols. This is a breakpoint -> cols map\n cols: _propTypes2.default.object,\n\n // layouts is an object mapping breakpoints to layouts.\n // e.g. {lg: Layout, md: Layout, ...}\n layouts: function layouts(props, propName) {\n if (type(props[propName]) !== '[object Object]') {\n throw new Error('Layout property must be an object. Received: ' + type(props[propName]));\n }\n Object.keys(props[propName]).forEach(function (key) {\n if (!(key in props.breakpoints)) {\n throw new Error('Each key in layouts must align with a key in breakpoints.');\n }\n (0, _utils.validateLayout)(props.layouts[key], 'layouts.' + key);\n });\n },\n\n\n // The width of this component.\n // Required in this propTypes stanza because generateInitialState() will fail without it.\n width: _propTypes2.default.number.isRequired,\n\n //\n // Callbacks\n //\n\n // Calls back with breakpoint and new # cols\n onBreakpointChange: _propTypes2.default.func,\n\n // Callback so you can save the layout.\n // Calls back with (currentLayout, allLayouts). allLayouts are keyed by breakpoint.\n onLayoutChange: _propTypes2.default.func,\n\n // Calls back with (containerWidth, margin, cols, containerPadding)\n onWidthChange: _propTypes2.default.func\n};\nResponsiveReactGridLayout.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 layouts: {},\n onBreakpointChange: noop,\n onLayoutChange: noop,\n onWidthChange: noop\n};\nexports.default = ResponsiveReactGridLayout;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(2);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(9);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/*\n * A simple HOC that provides facility for listening to container resizes.\n */\nvar WidthProvider = function WidthProvider(ComposedComponent) {\n var _class, _temp2;\n\n return _temp2 = _class = function (_React$Component) {\n _inherits(_class, _React$Component);\n\n function _class() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, _class);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n width: 1280\n }, _this.mounted = false, _this.onWindowResize = function (_event) {\n if (!_this.mounted) return;\n var node = _reactDom2.default.findDOMNode(_this); // Flow casts this to Text | Element\n if (node instanceof HTMLElement) _this.setState({ width: node.offsetWidth });\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _class.prototype.componentDidMount = function componentDidMount() {\n this.mounted = true;\n\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 _class.prototype.componentWillUnmount = function componentWillUnmount() {\n this.mounted = false;\n window.removeEventListener('resize', this.onWindowResize);\n };\n\n _class.prototype.render = function render() {\n if (this.props.measureBeforeMount && !this.mounted) {\n return _react2.default.createElement('div', { className: this.props.className, style: this.props.style });\n }\n\n return _react2.default.createElement(ComposedComponent, _extends({}, this.props, this.state));\n };\n\n return _class;\n }(_react2.default.Component), _class.defaultProps = {\n measureBeforeMount: false\n }, _class.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: _propTypes2.default.bool\n }, _temp2;\n};\n\nexports.default = WidthProvider;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(2);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDraggable = __webpack_require__(7);\n\nvar _reactResizable = __webpack_require__(18);\n\nvar _utils = __webpack_require__(1);\n\nvar _classnames = __webpack_require__(6);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * An individual item within a ReactGridLayout.\n */\nvar GridItem = function (_React$Component) {\n _inherits(GridItem, _React$Component);\n\n function GridItem() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, GridItem);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n resizing: null,\n dragging: null,\n className: ''\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n // Helper for generating column width\n GridItem.prototype.calcColWidth = function calcColWidth() {\n var _props = this.props,\n margin = _props.margin,\n containerPadding = _props.containerPadding,\n containerWidth = _props.containerWidth,\n cols = _props.cols;\n\n return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;\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 {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 {Object} Object containing coords.\n */\n\n\n GridItem.prototype.calcPosition = function calcPosition(x, y, w, h, state) {\n var _props2 = this.props,\n margin = _props2.margin,\n containerPadding = _props2.containerPadding,\n rowHeight = _props2.rowHeight;\n\n var colWidth = this.calcColWidth();\n\n var out = {\n left: Math.round((colWidth + margin[0]) * x + containerPadding[0]),\n top: Math.round((rowHeight + margin[1]) * y + containerPadding[1]),\n // 0 * Infinity === NaN, which causes problems with resize constraints;\n // Fix this if it occurs.\n // Note we do it here rather than later because Math.round(Infinity) causes deopt\n width: w === Infinity ? w : Math.round(colWidth * w + Math.max(0, w - 1) * margin[0]),\n height: h === Infinity ? h : Math.round(rowHeight * h + Math.max(0, h - 1) * margin[1])\n };\n\n if (state && state.resizing) {\n out.width = Math.round(state.resizing.width);\n out.height = Math.round(state.resizing.height);\n }\n\n if (state && state.dragging) {\n out.top = Math.round(state.dragging.top);\n out.left = Math.round(state.dragging.left);\n }\n\n return out;\n };\n\n /**\n * Translate x and y coordinates from pixels to grid units.\n * @param {Number} top Top position (relative to parent) in pixels.\n * @param {Number} left Left position (relative to parent) in pixels.\n * @return {Object} x and y in grid units.\n */\n\n\n GridItem.prototype.calcXY = function calcXY(top, left) {\n var _props3 = this.props,\n margin = _props3.margin,\n cols = _props3.cols,\n rowHeight = _props3.rowHeight,\n w = _props3.w,\n h = _props3.h,\n maxRows = _props3.maxRows;\n\n var colWidth = this.calcColWidth();\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 var x = Math.round((left - margin[0]) / (colWidth + margin[0]));\n var y = Math.round((top - margin[1]) / (rowHeight + margin[1]));\n\n // Capping\n x = Math.max(Math.min(x, cols - w), 0);\n y = Math.max(Math.min(y, maxRows - h), 0);\n\n return { x: x, y: y };\n };\n\n /**\n * Given a height and width in pixel values, calculate grid units.\n * @param {Number} height Height in pixels.\n * @param {Number} width Width in pixels.\n * @return {Object} w, h as grid units.\n */\n\n\n GridItem.prototype.calcWH = function calcWH(_ref) {\n var height = _ref.height,\n width = _ref.width;\n var _props4 = this.props,\n margin = _props4.margin,\n maxRows = _props4.maxRows,\n cols = _props4.cols,\n rowHeight = _props4.rowHeight,\n x = _props4.x,\n y = _props4.y;\n\n var colWidth = this.calcColWidth();\n\n // width = colWidth * w - (margin * (w - 1))\n // ...\n // w = (width + margin) / (colWidth + margin)\n var w = Math.round((width + margin[0]) / (colWidth + margin[0]));\n var h = Math.round((height + margin[1]) / (rowHeight + margin[1]));\n\n // Capping\n w = Math.max(Math.min(w, cols - x), 0);\n h = Math.max(Math.min(h, maxRows - y), 0);\n return { w: w, h: h };\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\n\n GridItem.prototype.createStyle = function createStyle(pos) {\n var _props5 = this.props,\n usePercentages = _props5.usePercentages,\n containerWidth = _props5.containerWidth,\n useCSSTransforms = _props5.useCSSTransforms;\n\n\n var style = void 0;\n // CSS Transforms support (default)\n if (useCSSTransforms) {\n style = (0, _utils.setTransform)(pos);\n }\n // top,left (slow)\n else {\n style = (0, _utils.setTopLeft)(pos);\n\n // This is used for server rendering.\n if (usePercentages) {\n style.left = (0, _utils.perc)(pos.left / containerWidth);\n style.width = (0, _utils.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\n\n GridItem.prototype.mixinDraggable = function mixinDraggable(child) {\n return _react2.default.createElement(\n _reactDraggable.DraggableCore,\n {\n onStart: this.onDragHandler('onDragStart'),\n onDrag: this.onDragHandler('onDrag'),\n onStop: this.onDragHandler('onDragStop'),\n handle: this.props.handle,\n cancel: \".react-resizable-handle\" + (this.props.cancel ? \",\" + this.props.cancel : \"\") },\n child\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\n\n GridItem.prototype.mixinResizable = function mixinResizable(child, position) {\n var _props6 = this.props,\n cols = _props6.cols,\n x = _props6.x,\n minW = _props6.minW,\n minH = _props6.minH,\n maxW = _props6.maxW,\n maxH = _props6.maxH;\n\n // This is the max possible width - doesn't go to infinity because of the width of the window\n\n var maxWidth = this.calcPosition(0, 0, cols - x, 0).width;\n\n // Calculate min/max constraints using our min & maxes\n var mins = this.calcPosition(0, 0, minW, minH);\n var maxes = this.calcPosition(0, 0, maxW, maxH);\n var minConstraints = [mins.width, mins.height];\n var maxConstraints = [Math.min(maxes.width, maxWidth), Math.min(maxes.height, Infinity)];\n return _react2.default.createElement(\n _reactResizable.Resizable,\n {\n width: position.width,\n height: position.height,\n minConstraints: minConstraints,\n maxConstraints: maxConstraints,\n onResizeStop: this.onResizeHandler('onResizeStop'),\n onResizeStart: this.onResizeHandler('onResizeStart'),\n onResize: this.onResizeHandler('onResize') },\n child\n );\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\n\n GridItem.prototype.onDragHandler = function onDragHandler(handlerName) {\n var _this2 = this;\n\n return function (e, _ref2) {\n var node = _ref2.node,\n deltaX = _ref2.deltaX,\n deltaY = _ref2.deltaY;\n\n if (!_this2.props[handlerName]) return;\n\n var newPosition = { top: 0, left: 0 };\n\n // Get new XY\n switch (handlerName) {\n case 'onDragStart':\n {\n // ToDo this wont work on nested parents\n var parentRect = node.offsetParent.getBoundingClientRect();\n var clientRect = node.getBoundingClientRect();\n newPosition.left = clientRect.left - parentRect.left;\n newPosition.top = clientRect.top - parentRect.top;\n _this2.setState({ dragging: newPosition });\n break;\n }\n case 'onDrag':\n if (!_this2.state.dragging) throw new Error('onDrag called before onDragStart.');\n newPosition.left = _this2.state.dragging.left + deltaX;\n newPosition.top = _this2.state.dragging.top + deltaY;\n _this2.setState({ dragging: newPosition });\n break;\n case 'onDragStop':\n if (!_this2.state.dragging) throw new Error('onDragEnd called before onDragStart.');\n newPosition.left = _this2.state.dragging.left;\n newPosition.top = _this2.state.dragging.top;\n _this2.setState({ dragging: null });\n break;\n default:\n throw new Error('onDragHandler called with unrecognized handlerName: ' + handlerName);\n }\n\n var _calcXY = _this2.calcXY(newPosition.top, newPosition.left),\n x = _calcXY.x,\n y = _calcXY.y;\n\n _this2.props[handlerName](_this2.props.i, x, y, { e: e, node: node, newPosition: newPosition });\n };\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\n\n GridItem.prototype.onResizeHandler = function onResizeHandler(handlerName) {\n var _this3 = this;\n\n return function (e, _ref3) {\n var node = _ref3.node,\n size = _ref3.size;\n\n if (!_this3.props[handlerName]) return;\n var _props7 = _this3.props,\n cols = _props7.cols,\n x = _props7.x,\n i = _props7.i,\n maxW = _props7.maxW,\n minW = _props7.minW,\n maxH = _props7.maxH,\n minH = _props7.minH;\n\n // Get new XY\n\n var _calcWH = _this3.calcWH(size),\n w = _calcWH.w,\n h = _calcWH.h;\n\n // Cap w at numCols\n\n\n w = Math.min(w, cols - x);\n // Ensure w is at least 1\n w = Math.max(w, 1);\n\n // Min/max capping\n w = Math.max(Math.min(w, maxW), minW);\n h = Math.max(Math.min(h, maxH), minH);\n\n _this3.setState({ resizing: handlerName === 'onResizeStop' ? null : size });\n\n _this3.props[handlerName](i, w, h, { e: e, node: node, size: size });\n };\n };\n\n GridItem.prototype.render = function render() {\n var _props8 = this.props,\n x = _props8.x,\n y = _props8.y,\n w = _props8.w,\n h = _props8.h,\n isDraggable = _props8.isDraggable,\n isResizable = _props8.isResizable,\n useCSSTransforms = _props8.useCSSTransforms;\n\n\n var pos = this.calcPosition(x, y, w, h, this.state);\n var child = _react2.default.Children.only(this.props.children);\n\n // Create the child element. We clone the existing element but modify its className and style.\n var newChild = _react2.default.cloneElement(child, {\n className: (0, _classnames2.default)('react-grid-item', child.props.className, this.props.className, {\n static: this.props.static,\n resizing: Boolean(this.state.resizing),\n 'react-draggable': isDraggable,\n 'react-draggable-dragging': Boolean(this.state.dragging),\n cssTransforms: useCSSTransforms\n }),\n // We can set the width and height on the child, but unfortunately we can't set the position.\n style: _extends({}, this.props.style, child.props.style, this.createStyle(pos))\n });\n\n // Resizable support. This is usually on but the user can toggle it off.\n if (isResizable) newChild = this.mixinResizable(newChild, pos);\n\n // Draggable support. This is always on, except for with placeholders.\n if (isDraggable) newChild = this.mixinDraggable(newChild);\n\n return newChild;\n };\n\n return GridItem;\n}(_react2.default.Component);\n\nGridItem.propTypes = {\n // Children must be only a single element\n children: _propTypes2.default.element,\n\n // General grid attributes\n cols: _propTypes2.default.number.isRequired,\n containerWidth: _propTypes2.default.number.isRequired,\n rowHeight: _propTypes2.default.number.isRequired,\n margin: _propTypes2.default.array.isRequired,\n maxRows: _propTypes2.default.number.isRequired,\n containerPadding: _propTypes2.default.array.isRequired,\n\n // These are all in grid units\n x: _propTypes2.default.number.isRequired,\n y: _propTypes2.default.number.isRequired,\n w: _propTypes2.default.number.isRequired,\n h: _propTypes2.default.number.isRequired,\n\n // All optional\n minW: function minW(props, propName) {\n var value = props[propName];\n if (typeof value !== 'number') return new Error('minWidth not Number');\n if (value > props.w || value > props.maxW) return new Error('minWidth larger than item width/maxWidth');\n },\n\n maxW: function maxW(props, propName) {\n var value = props[propName];\n if (typeof value !== 'number') return new Error('maxWidth not Number');\n if (value < props.w || value < props.minW) return new Error('maxWidth smaller than item width/minWidth');\n },\n\n minH: function minH(props, propName) {\n var value = props[propName];\n if (typeof value !== 'number') return new Error('minHeight not Number');\n if (value > props.h || value > props.maxH) return new Error('minHeight larger than item height/maxHeight');\n },\n\n maxH: function maxH(props, propName) {\n var value = props[propName];\n if (typeof value !== 'number') return new Error('maxHeight not Number');\n if (value < props.h || value < props.minH) return new Error('maxHeight smaller than item height/minHeight');\n },\n\n // ID is nice to have for callbacks\n i: _propTypes2.default.string.isRequired,\n\n // Functions\n onDragStop: _propTypes2.default.func,\n onDragStart: _propTypes2.default.func,\n onDrag: _propTypes2.default.func,\n onResizeStop: _propTypes2.default.func,\n onResizeStart: _propTypes2.default.func,\n onResize: _propTypes2.default.func,\n\n // Flags\n isDraggable: _propTypes2.default.bool.isRequired,\n isResizable: _propTypes2.default.bool.isRequired,\n static: _propTypes2.default.bool,\n\n // Use CSS transforms instead of top/left\n useCSSTransforms: _propTypes2.default.bool.isRequired,\n\n // Others\n className: _propTypes2.default.string,\n // Selector for draggable handle\n handle: _propTypes2.default.string,\n // Selector for draggable cancel (see react-draggable)\n cancel: _propTypes2.default.string\n};\nGridItem.defaultProps = {\n className: '',\n cancel: '',\n minH: 1,\n minW: 1,\n maxH: Infinity,\n maxW: Infinity\n};\nexports.default = GridItem;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n return function () {\n return arg;\n };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n return arg;\n};\n\nmodule.exports = emptyFunction;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (false) {\n validateFormat = function validateFormat(format) {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n validateFormat(format);\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(format.replace(/%s/g, function () {\n return args[argIndex++];\n }));\n error.name = 'Invariant Violation';\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n}\n\nmodule.exports = invariant;\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n\n\nvar emptyFunction = __webpack_require__(13);\nvar invariant = __webpack_require__(14);\n\nmodule.exports = function() {\n // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n function shim() {\n invariant(\n false,\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 };\n shim.isRequired = shim;\n function getShim() {\n return shim;\n };\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 instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim\n };\n\n ReactPropTypes.checkPropTypes = emptyFunction;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _Resizable = __webpack_require__(8);\n\nvar _Resizable2 = _interopRequireDefault(_Resizable);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/*:: import type {Props as ResizableProps} from './Resizable';*/\n/*:: type State = {width: number, height: number};*/\n/*:: type Size = {width: number, height: number};*/\n\n\n// An example use of Resizable.\n/*:: type ResizeData = {element: Element, size: Size};*/\n\nvar ResizableBox = function (_React$Component) {\n _inherits(ResizableBox, _React$Component);\n\n function ResizableBox() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, ResizableBox);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n width: _this.props.width,\n height: _this.props.height\n }, _this.onResize = function (e /*: Event*/, _ref) {\n var element = _ref.element,\n size = _ref.size;\n var width = size.width,\n height = size.height;\n\n\n if (_this.props.onResize) {\n e.persist && e.persist();\n _this.setState(size, function () {\n return _this.props.onResize(e, { element: element, size: size });\n });\n } else {\n _this.setState(size);\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n ResizableBox.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps /*: ResizableProps*/) {\n if (nextProps.width !== this.props.width || nextProps.height !== this.props.height) {\n this.setState({\n width: nextProps.width,\n height: nextProps.height\n });\n }\n };\n\n ResizableBox.prototype.render = function render() /*: React.Element*/ {\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 _props = this.props,\n handleSize = _props.handleSize,\n onResize = _props.onResize,\n onResizeStart = _props.onResizeStart,\n onResizeStop = _props.onResizeStop,\n draggableOpts = _props.draggableOpts,\n minConstraints = _props.minConstraints,\n maxConstraints = _props.maxConstraints,\n lockAspectRatio = _props.lockAspectRatio,\n axis = _props.axis,\n width = _props.width,\n height = _props.height,\n props = _objectWithoutProperties(_props, ['handleSize', 'onResize', 'onResizeStart', 'onResizeStop', 'draggableOpts', 'minConstraints', 'maxConstraints', 'lockAspectRatio', 'axis', 'width', 'height']);\n\n return _react2.default.createElement(\n _Resizable2.default,\n {\n handleSize: handleSize,\n width: this.state.width,\n height: this.state.height,\n onResizeStart: onResizeStart,\n onResize: this.onResize,\n onResizeStop: onResizeStop,\n draggableOpts: draggableOpts,\n minConstraints: minConstraints,\n maxConstraints: maxConstraints,\n lockAspectRatio: lockAspectRatio,\n axis: axis\n },\n _react2.default.createElement('div', _extends({ style: { width: this.state.width + 'px', height: this.state.height + 'px' } }, props))\n );\n };\n\n return ResizableBox;\n}(_react2.default.Component);\n\nResizableBox.propTypes = {\n height: _react.PropTypes.number,\n width: _react.PropTypes.number\n};\nResizableBox.defaultProps = {\n handleSize: [20, 20]\n};\nexports.default = ResizableBox;\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _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; };\n\nvar _react = __webpack_require__(0);\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// React.addons.cloneWithProps look-alike that merges style & className.\nmodule.exports = function cloneElement(element /*: React.Element*/, props /*: Object*/) /*: React.Element*/ {\n if (props.style && element.props.style) {\n props.style = _extends({}, element.props.style, props.style);\n }\n if (props.className && element.props.className) {\n props.className = element.props.className + ' ' + props.className;\n }\n return _react2.default.cloneElement(element, props);\n};\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function() {\n throw new Error(\"Don't instantiate Resizable directly! Use require('react-resizable').Resizable\");\n};\n\nmodule.exports.Resizable = __webpack_require__(8).default;\nmodule.exports.ResizableBox = __webpack_require__(16).default;\n\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(4).default;\nmodule.exports.utils = __webpack_require__(1);\nmodule.exports.Responsive = __webpack_require__(10).default;\nmodule.exports.Responsive.utils = __webpack_require__(5);\nmodule.exports.WidthProvider = __webpack_require__(11).default;\n\n/***/ })\n/******/ ]);\n});\n\n\n// WEBPACK FOOTER //\n// react-grid-layout.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 21);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 038efeaf0f5ec9ce105f","module.exports = __WEBPACK_EXTERNAL_MODULE_0__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}\n// module id = 0\n// module chunks = 0","// @flow\nimport isEqual from 'lodash.isequal';\nimport React from 'react';\nexport type LayoutItemRequired = {w: number, h: number, x: number, y: number, i: string};\nexport type LayoutItem = LayoutItemRequired &\n {minW?: number, minH?: number, maxW?: number, maxH?: number,\n moved?: boolean, static?: boolean,\n isDraggable?: ?boolean, isResizable?: ?boolean};\nexport type Layout = Array;\nexport type Position = {left: number, top: number, width: number, height: number};\nexport type DragCallbackData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number\n};\nexport type DragEvent = {e: Event} & DragCallbackData;\nexport type Size = {width: number, height: number};\nexport type ResizeEvent = {e: Event, node: HTMLElement, size: Size};\nexport type ReactChildren = React.Element[] | React.Element | {[key: string] : React.Element};\n\nconst isProduction = process.env.NODE_ENV === 'production';\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, 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// Fast path to cloning, since this is monomorphic\nexport function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem {\n return {\n w: layoutItem.w, h: layoutItem.h, x: layoutItem.x, y: layoutItem.y, i: layoutItem.i,\n minW: layoutItem.minW, maxW: layoutItem.maxW, minH: layoutItem.minH, maxH: layoutItem.maxH,\n moved: Boolean(layoutItem.moved), static: Boolean(layoutItem.static),\n // These can be null\n isDraggable: layoutItem.isDraggable, isResizable: layoutItem.isResizable\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(React.Children.map(a, c => c.key), React.Children.map(b, c => c.key));\n}\n\n/**\n * Given two layoutitems, check if they collide.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n if (l1 === l2) 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 * @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(layout: Layout, verticalCompact: boolean): 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 = sortLayoutItemsByRowCol(layout);\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, verticalCompact);\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\n/**\n * Compact an item in the layout.\n */\nexport function compactItem(compareWith: Layout, l: LayoutItem, verticalCompact: boolean): LayoutItem {\n if (verticalCompact) {\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\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 }\n\n // Move it down, and keep moving it down if it's colliding.\n let collides;\n while((collides = getFirstCollision(compareWith, l))) {\n l.y = collides.y + collides.h;\n }\n return l;\n}\n\n/**\n * Given a layout, make sure all elements fit within its bounds.\n *\n * @param {Array} layout Layout array.\n * @param {Number} bounds Number of columns.\n */\nexport function correctBounds(layout: Layout, bounds: {cols: number}): 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(layout: Layout, layoutItem: LayoutItem): ?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(layout: Layout, layoutItem: LayoutItem): Array {\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 {\n return layout.filter((l) => l.static);\n}\n\n/**\n * Move an element. Responsible for doing cascading movements of other elements.\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 * @param {Boolean} [isUserAction] If true, designates that the item we're moving is\n * being dragged/resized by the user.\n */\nexport function moveElement(layout: Layout, l: LayoutItem, x: ?number, y: ?number, isUserAction: ?boolean): Layout {\n if (l.static) return layout;\n\n // Short-circuit if nothing to do.\n if (l.y === y && l.x === x) return layout;\n\n const movingUp = y && l.y > y;\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 = sortLayoutItemsByRowCol(layout);\n if (movingUp) sorted = sorted.reverse();\n const collisions = getAllCollisions(sorted, l);\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 // console.log('resolving collision between', l.i, 'at', l.y, 'and', collision.i, 'at', collision.y);\n\n // Short circuit so we can't infinite loop\n if (collision.moved) continue;\n\n // This makes it feel a bit more precise by waiting to swap for just a bit when moving up.\n if (l.y > collision.y && l.y - collision.y > collision.h / 4) continue;\n\n // Don't move static items - we have to move *this* element away\n if (collision.static) {\n layout = moveElementAwayFromCollision(layout, collision, l, isUserAction);\n } else {\n layout = moveElementAwayFromCollision(layout, l, collision, isUserAction);\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 * @param {Boolean} [isUserAction] If true, designates that the item we're moving is being dragged/resized\n * by the user.\n */\nexport function moveElementAwayFromCollision(layout: Layout, collidesWith: LayoutItem,\n itemToMove: LayoutItem, isUserAction: ?boolean): Layout {\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 // Make a mock item so we don't modify the item here, only modify in moveElement.\n const fakeItem: LayoutItem = {\n x: itemToMove.x,\n y: itemToMove.y,\n w: itemToMove.w,\n h: itemToMove.h,\n i: '-1'\n };\n fakeItem.y = Math.max(collidesWith.y - itemToMove.h, 0);\n if (!getFirstCollision(layout, fakeItem)) {\n return moveElement(layout, itemToMove, undefined, fakeItem.y);\n }\n }\n\n // Previously this was optimized to move below the collision directly, but this can cause problems\n // with cascading moves, as an item may actually leapfrog a collision and cause a reversal in order.\n return moveElement(layout, itemToMove, undefined, itemToMove.y + 1);\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 sortLayoutItemsByRowCol(layout: Layout): Layout {\n return [].concat(layout).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 * Generate a layout using the initialLayout and children as a template.\n * Missing entries will be added, extraneous ones will be truncated.\n *\n * @param {Array} initialLayout Layout passed in through props.\n * @param {String} breakpoint Current responsive breakpoint.\n * @param {Boolean} verticalCompact Whether or not to compact the layout vertically.\n * @return {Array} Working layout.\n */\nexport function synchronizeLayoutWithChildren(initialLayout: Layout, children: ReactChildren,\n cols: number, verticalCompact: boolean): Layout {\n initialLayout = initialLayout || [];\n\n // Generate one layout item per child.\n let layout: Layout = [];\n React.Children.forEach(children, (child: React.Element, i: number) => {\n // Don't overwrite if it already exists.\n const exists = getLayoutItem(initialLayout, child.key || \"1\" /* FIXME satisfies Flow */);\n if (exists) {\n layout[i] = cloneLayoutItem(exists);\n } else {\n if (!isProduction && child.props._grid) {\n console.warn('`_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 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\n layout[i] = cloneLayoutItem({...g, i: child.key});\n } else {\n // Nothing provided: ensure this is added to the bottom\n layout[i] = cloneLayoutItem({w: 1, h: 1, x: 0, y: bottom(layout), i: child.key || \"1\"});\n }\n }\n });\n\n // Correct the layout.\n layout = correctBounds(layout, {cols: cols});\n layout = compact(layout, verticalCompact);\n\n return layout;\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(layout: Layout, contextName: string): void {\n contextName = contextName || \"Layout\";\n const subProps = ['x', 'y', 'w', 'h'];\n if (!Array.isArray(layout)) 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('ReactGridLayout: ' + contextName + '[' + i + '].' + subProps[j] + ' must be a number!');\n }\n }\n if (item.i && typeof item.i !== 'string') {\n throw new Error('ReactGridLayout: ' + contextName + '[' + i + '].i must be a string!');\n }\n if (item.static !== undefined && typeof item.static !== 'boolean') {\n throw new Error('ReactGridLayout: ' + contextName + '[' + i + '].static must be a boolean!');\n }\n }\n}\n\n// Flow can't really figure this out, so we just use Object\nexport function autoBindHandlers(el: Object, fns: Array): void {\n fns.forEach((key) => el[key] = el[key].bind(el));\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils.js","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n Symbol.for &&\n Symbol.for('react.element')) ||\n 0xeac7;\n\n var isValidElement = function(object) {\n return typeof object === 'object' &&\n object !== null &&\n object.$$typeof === REACT_ELEMENT_TYPE;\n };\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')(isValidElement, 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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/index.js\n// module id = 2\n// module chunks = 0","/**\n * Lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash.isequal/index.js\n// module id = 3\n// module chunks = 0","// @flow\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport isEqual from 'lodash.isequal';\nimport classNames from 'classnames';\nimport {autoBindHandlers, bottom, childrenEqual, cloneLayoutItem, compact, getLayoutItem, moveElement,\n synchronizeLayoutWithChildren, validateLayout} from './utils';\nimport GridItem from './GridItem';\nconst noop = function() {};\n\n// Types\nimport type {ResizeEvent, DragEvent, Layout, LayoutItem} from './utils';\ntype State = {\n activeDrag: ?LayoutItem,\n layout: Layout,\n mounted: boolean,\n oldDragItem: ?LayoutItem,\n oldLayout: ?Layout,\n oldResizeItem: ?LayoutItem\n};\n// End Types\n\n/**\n * A reactive, fluid grid layout with draggable, resizable components.\n */\n\nexport default class ReactGridLayout extends React.Component {\n // TODO publish internal ReactClass displayName transform\n static displayName = \"ReactGridLayout\";\n\n static propTypes = {\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 // If true, the layout will compact vertically\n verticalCompact: PropTypes.bool,\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) {\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 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),\n // Padding inside the container [x, y] in px\n containerPadding: PropTypes.arrayOf(PropTypes.number),\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 isDraggable: PropTypes.bool,\n isResizable: PropTypes.bool,\n // Use CSS transforms instead of top/left\n useCSSTransforms: PropTypes.bool,\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).\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\n //\n // Other validations\n //\n\n // Children must not have duplicate keys.\n children: function (props, propName, _componentName) {\n var children = props[propName];\n\n // Check children keys for duplicates. Throw if found.\n var keys = {};\n React.Children.forEach(children, function (child) {\n if (keys[child.key]) {\n throw new Error(\"Duplicate child key found! This will cause problems in ReactGridLayout.\");\n }\n keys[child.key] = true;\n });\n }\n };\n\n static defaultProps = {\n autoSize: true,\n cols: 12,\n className: '',\n rowHeight: 150,\n maxRows: Infinity, // infinite vertical growth\n layout: [],\n margin: [10, 10],\n isDraggable: true,\n isResizable: true,\n useCSSTransforms: true,\n verticalCompact: true,\n onLayoutChange: noop,\n onDragStart: noop,\n onDrag: noop,\n onDragStop: noop,\n onResizeStart: noop,\n onResize: noop,\n onResizeStop: noop\n };\n\n state: State = {\n activeDrag: null,\n layout: synchronizeLayoutWithChildren(this.props.layout, this.props.children,\n this.props.cols, this.props.verticalCompact),\n mounted: false,\n oldDragItem: null,\n oldLayout: null,\n oldResizeItem: null,\n };\n\n constructor(props: $PropertyType, context: any): void {\n super(props, context);\n autoBindHandlers(this, ['onDragStart', 'onDrag', 'onDragStop', 'onResizeStart', 'onResize', 'onResizeStop']);\n }\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 componentWillReceiveProps(nextProps: $PropertyType) {\n let newLayoutBase;\n // Allow parent to set layout directly.\n if (!isEqual(nextProps.layout, this.props.layout)) {\n newLayoutBase = nextProps.layout;\n }\n\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 else if (!childrenEqual(this.props.children, nextProps.children)) {\n newLayoutBase = this.state.layout;\n }\n\n // We need to regenerate the layout.\n if (newLayoutBase) {\n const newLayout = synchronizeLayoutWithChildren(newLayoutBase, nextProps.children,\n nextProps.cols, nextProps.verticalCompact);\n const oldLayout = this.state.layout;\n this.setState({layout: newLayout});\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() {\n if (!this.props.autoSize) return;\n const nbRow = bottom(this.state.layout);\n const containerPaddingY = this.props.containerPadding ? this.props.containerPadding[1] : this.props.margin[1];\n return nbRow * this.props.rowHeight + (nbRow - 1) * this.props.margin[1] + containerPaddingY * 2 + 'px';\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, {e, node}: DragEvent) {\n const {layout} = this.state;\n var l = getLayoutItem(layout, i);\n if (!l) return;\n\n this.setState({oldDragItem: cloneLayoutItem(l), oldLayout: this.state.layout});\n\n 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, {e, node}: DragEvent) {\n const {oldDragItem} = this.state;\n let {layout} = this.state;\n var l = getLayoutItem(layout, i);\n if (!l) return;\n\n // Create placeholder (display only)\n var placeholder = {\n w: l.w, h: l.h, x: l.x, y: l.y, placeholder: true, i: i\n };\n\n // Move the element to the dragged location.\n layout = moveElement(layout, l, x, y, true /* isUserAction */);\n\n this.props.onDrag(layout, oldDragItem, l, placeholder, e, node);\n\n this.setState({\n layout: compact(layout, this.props.verticalCompact),\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, {e, node}: DragEvent) {\n const {oldDragItem} = this.state;\n let {layout} = this.state;\n const l = getLayoutItem(layout, i);\n if (!l) return;\n\n // Move the element here\n layout = moveElement(layout, l, x, y, true /* isUserAction */);\n\n this.props.onDragStop(layout, oldDragItem, l, null, e, node);\n\n // Set state\n const newLayout = compact(layout, this.props.verticalCompact);\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 if (!isEqual(oldLayout, newLayout)) {\n this.props.onLayoutChange(newLayout);\n }\n }\n\n onResizeStart(i:string, w:number, h:number, {e, node}: ResizeEvent) {\n const {layout} = this.state;\n var 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, {e, node}: ResizeEvent) {\n const {layout, oldResizeItem} = this.state;\n var l = getLayoutItem(layout, i);\n if (!l) return;\n\n // Set new width and height.\n l.w = w;\n l.h = h;\n\n // Create placeholder element (display only)\n var placeholder = {\n w: w, h: h, x: l.x, y: l.y, static: true, i: i\n };\n\n this.props.onResize(layout, oldResizeItem, l, placeholder, e, node);\n\n // Re-compact the layout and set the drag placeholder.\n this.setState({\n layout: compact(layout, this.props.verticalCompact),\n activeDrag: placeholder\n });\n }\n\n onResizeStop(i:string, w:number, h:number, {e, node}: ResizeEvent) {\n const {layout, oldResizeItem} = this.state;\n var l = getLayoutItem(layout, i);\n\n this.props.onResizeStop(layout, oldResizeItem, l, null, e, node);\n\n // Set state\n const newLayout = compact(layout, this.props.verticalCompact);\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(): ?React.Element {\n const {activeDrag} = this.state;\n if (!activeDrag) return null;\n const {width, cols, margin, containerPadding, rowHeight, maxRows, useCSSTransforms} = this.props;\n\n // {...this.state.activeDrag} is pretty slow, actually\n return (\n \n \n \n );\n }\n\n /**\n * Given a grid item, set its style attributes & surround in a .\n * @param {Element} child React element.\n * @return {Element} Element wrapped in draggable and properly placed.\n */\n processGridItem(child: React.Element): ?React.Element {\n if (!child.key) return;\n const l = getLayoutItem(this.state.layout, child.key);\n if (!l) return null;\n const {width, cols, margin, containerPadding, rowHeight,\n maxRows, isDraggable, isResizable, useCSSTransforms,\n draggableCancel, draggableHandle} = this.props;\n const {mounted} = this.state;\n\n // Parse 'static'. Any properties defined directly on the grid item will take precedence.\n const draggable = Boolean(!l.static && isDraggable && (l.isDraggable || l.isDraggable == null));\n const resizable = Boolean(!l.static && isResizable && (l.isResizable || l.isResizable == null));\n\n return (\n \n {child}\n \n );\n }\n\n render() {\n const {className, style} = this.props;\n\n const mergedStyle = {\n height: this.containerHeight(),\n ...style\n };\n\n return (\n
\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/ReactGridLayout.jsx","// @flow\n\nimport {cloneLayout, compact, correctBounds} from './utils';\n\nimport type {Layout} from './utils';\nexport type ResponsiveLayout = {lg?: Layout, md?: Layout, sm?: Layout, xs?: Layout, xxs?: Layout};\ntype Breakpoint = string;\ntype Breakpoints = {lg?: number, md?: number, sm?: number, xs?: number, xxs?: number};\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(breakpoints: Breakpoints, width: number): 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/**\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(breakpoint: Breakpoint, cols: Breakpoints): number {\n if (!cols[breakpoint]) {\n throw new Error(\"ResponsiveReactGridLayout: `cols` entry for breakpoint \" + breakpoint + \" is missing!\");\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(layouts: ResponsiveLayout, breakpoints: Breakpoints,\n breakpoint: Breakpoint, lastBreakpoint: Breakpoint,\n cols: number, verticalCompact: boolean): 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(breakpointsSorted.indexOf(breakpoint));\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}), verticalCompact);\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(breakpoints: Breakpoints): Array {\n const keys: Array = Object.keys(breakpoints);\n return keys.sort(function(a, b) {\n return breakpoints[a] - breakpoints[b];\n });\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/responsiveUtils.js","/*!\n Copyright (c) 2016 Jed Watson.\n Licensed under the MIT License (MIT), see\n http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/classnames/index.js\n// module id = 6\n// module chunks = 0","(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[\"ReactDraggable\"] = factory(require(\"react\"), require(\"react-dom\"));\n\telse\n\t\troot[\"ReactDraggable\"] = factory(root[\"React\"], root[\"ReactDOM\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(1).default;\n\tmodule.exports.DraggableCore = __webpack_require__(9).default;\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _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; };\n\t\n\tvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_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\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\t\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _react = __webpack_require__(2);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _classnames = __webpack_require__(4);\n\t\n\tvar _classnames2 = _interopRequireDefault(_classnames);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tvar _positionFns = __webpack_require__(8);\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _DraggableCore = __webpack_require__(9);\n\t\n\tvar _DraggableCore2 = _interopRequireDefault(_DraggableCore);\n\t\n\tvar _log = __webpack_require__(11);\n\t\n\tvar _log2 = _interopRequireDefault(_log);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _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\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t// $FlowIgnore\n\t\n\t\n\t/*:: import type {DraggableEventHandler} from './utils/types';*/\n\t/*:: type DraggableState = {\n\t dragging: boolean,\n\t dragged: boolean,\n\t x: number, y: number,\n\t slackX: number, slackY: number,\n\t isElementSVG: boolean\n\t};*/\n\t\n\t\n\t//\n\t// Define \n\t//\n\t\n\t/*:: type ConstructorProps = {\n\t position: { x: number, y: number },\n\t defaultPosition: { x: number, y: number }\n\t};*/\n\t\n\tvar Draggable = function (_React$Component) {\n\t _inherits(Draggable, _React$Component);\n\t\n\t function Draggable(props /*: ConstructorProps*/) {\n\t _classCallCheck(this, Draggable);\n\t\n\t var _this = _possibleConstructorReturn(this, (Draggable.__proto__ || Object.getPrototypeOf(Draggable)).call(this, props));\n\t\n\t _this.onDragStart = function (e, coreData) {\n\t (0, _log2.default)('Draggable: onDragStart: %j', coreData);\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_this, coreData));\n\t // Kills start event on core as well, so move handlers are never bound.\n\t if (shouldStart === false) return false;\n\t\n\t _this.setState({ dragging: true, dragged: true });\n\t };\n\t\n\t _this.onDrag = function (e, coreData) {\n\t if (!_this.state.dragging) return false;\n\t (0, _log2.default)('Draggable: onDrag: %j', coreData);\n\t\n\t var uiData = (0, _positionFns.createDraggableData)(_this, coreData);\n\t\n\t var newState /*: $Shape*/ = {\n\t x: uiData.x,\n\t y: uiData.y\n\t };\n\t\n\t // Keep within bounds.\n\t if (_this.props.bounds) {\n\t // Save original x and y.\n\t var _x = newState.x,\n\t _y = newState.y;\n\t\n\t // Add slack to the values used to calculate bound position. This will ensure that if\n\t // we start removing slack, the element won't react to it right away until it's been\n\t // completely removed.\n\t\n\t newState.x += _this.state.slackX;\n\t newState.y += _this.state.slackY;\n\t\n\t // Get bound position. This will ceil/floor the x and y within the boundaries.\n\t // $FlowBug\n\t\n\t // Recalculate slack by noting how much was shaved by the boundPosition handler.\n\t var _getBoundPosition = (0, _positionFns.getBoundPosition)(_this, newState.x, newState.y);\n\t\n\t var _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2);\n\t\n\t newState.x = _getBoundPosition2[0];\n\t newState.y = _getBoundPosition2[1];\n\t newState.slackX = _this.state.slackX + (_x - newState.x);\n\t newState.slackY = _this.state.slackY + (_y - newState.y);\n\t\n\t // Update the event we fire to reflect what really happened after bounds took effect.\n\t uiData.x = _x;\n\t uiData.y = _y;\n\t uiData.deltaX = newState.x - _this.state.x;\n\t uiData.deltaY = newState.y - _this.state.y;\n\t }\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldUpdate = _this.props.onDrag(e, uiData);\n\t if (shouldUpdate === false) return false;\n\t\n\t _this.setState(newState);\n\t };\n\t\n\t _this.onDragStop = function (e, coreData) {\n\t if (!_this.state.dragging) return false;\n\t\n\t // Short-circuit if user's callback killed it.\n\t var shouldStop = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_this, coreData));\n\t if (shouldStop === false) return false;\n\t\n\t (0, _log2.default)('Draggable: onDragStop: %j', coreData);\n\t\n\t var newState /*: $Shape*/ = {\n\t dragging: false,\n\t slackX: 0,\n\t slackY: 0\n\t };\n\t\n\t // If this is a controlled component, the result of this operation will be to\n\t // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n\t var controlled = Boolean(_this.props.position);\n\t if (controlled) {\n\t var _this$props$position = _this.props.position,\n\t _x2 = _this$props$position.x,\n\t _y2 = _this$props$position.y;\n\t\n\t newState.x = _x2;\n\t newState.y = _y2;\n\t }\n\t\n\t _this.setState(newState);\n\t };\n\t\n\t _this.state = {\n\t // Whether or not we are currently dragging.\n\t dragging: false,\n\t\n\t // Whether or not we have been dragged before.\n\t dragged: false,\n\t\n\t // Current transform x and y.\n\t x: props.position ? props.position.x : props.defaultPosition.x,\n\t y: props.position ? props.position.y : props.defaultPosition.y,\n\t\n\t // Used for compensating for out-of-bounds drags\n\t slackX: 0, slackY: 0,\n\t\n\t // Can only determine if SVG after mounting\n\t isElementSVG: false\n\t };\n\t return _this;\n\t }\n\t\n\t _createClass(Draggable, [{\n\t key: 'componentWillMount',\n\t value: function componentWillMount() {\n\t if (this.props.position && !(this.props.onDrag || this.props.onStop)) {\n\t // eslint-disable-next-line\n\t console.warn('A `position` was applied to this , 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\t }\n\t }\n\t }, {\n\t key: 'componentDidMount',\n\t value: function componentDidMount() {\n\t // Check to see if the element passed is an instanceof SVGElement\n\t if (typeof SVGElement !== 'undefined' && _reactDom2.default.findDOMNode(this) instanceof SVGElement) {\n\t this.setState({ isElementSVG: true });\n\t }\n\t }\n\t }, {\n\t key: 'componentWillReceiveProps',\n\t value: function componentWillReceiveProps(nextProps /*: Object*/) {\n\t // Set x/y if position has changed\n\t if (nextProps.position && (!this.props.position || nextProps.position.x !== this.props.position.x || nextProps.position.y !== this.props.position.y)) {\n\t this.setState({ x: nextProps.position.x, y: nextProps.position.y });\n\t }\n\t }\n\t }, {\n\t key: 'componentWillUnmount',\n\t value: function componentWillUnmount() {\n\t this.setState({ dragging: false }); // prevents invariant if unmounted while dragging\n\t }\n\t }, {\n\t key: 'render',\n\t value: function render() /*: React.Element*/ {\n\t var _classNames;\n\t\n\t var style = {},\n\t svgTransform = null;\n\t\n\t // If this is controlled, we don't want to move it - unless it's dragging.\n\t var controlled = Boolean(this.props.position);\n\t var draggable = !controlled || this.state.dragging;\n\t\n\t var position = this.props.position || this.props.defaultPosition;\n\t var transformOpts = {\n\t // Set left if horizontal drag is enabled\n\t x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : position.x,\n\t\n\t // Set top if vertical drag is enabled\n\t y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : position.y\n\t };\n\t\n\t // If this element was SVG, we use the `transform` attribute.\n\t if (this.state.isElementSVG) {\n\t svgTransform = (0, _domFns.createSVGTransform)(transformOpts);\n\t } else {\n\t // Add a CSS transform to move the element around. This allows us to move the element around\n\t // without worrying about whether or not it is relatively or absolutely positioned.\n\t // If the item you are dragging already has a transform set, wrap it in a so \n\t // has a clean slate.\n\t style = (0, _domFns.createCSSTransform)(transformOpts);\n\t }\n\t\n\t var _props = this.props,\n\t defaultClassName = _props.defaultClassName,\n\t defaultClassNameDragging = _props.defaultClassNameDragging,\n\t defaultClassNameDragged = _props.defaultClassNameDragged;\n\t\n\t // Mark with class while dragging\n\t\n\t var className = (0, _classnames2.default)(this.props.children.props.className || '', defaultClassName, (_classNames = {}, _defineProperty(_classNames, defaultClassNameDragging, this.state.dragging), _defineProperty(_classNames, defaultClassNameDragged, this.state.dragged), _classNames));\n\t\n\t // Reuse the child provided\n\t // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\t return _react2.default.createElement(\n\t _DraggableCore2.default,\n\t _extends({}, this.props, { onStart: this.onDragStart, onDrag: this.onDrag, onStop: this.onDragStop }),\n\t _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n\t className: className,\n\t style: _extends({}, this.props.children.props.style, style),\n\t transform: svgTransform\n\t })\n\t );\n\t }\n\t }]);\n\t\n\t return Draggable;\n\t}(_react2.default.Component);\n\t\n\tDraggable.displayName = 'Draggable';\n\tDraggable.propTypes = _extends({}, _DraggableCore2.default.propTypes, {\n\t\n\t /**\n\t * `axis` determines which axis the draggable can move.\n\t *\n\t * Note that all callbacks will still return data as normal. This only\n\t * controls flushing to the DOM.\n\t *\n\t * 'both' allows movement horizontally and vertically.\n\t * 'x' limits movement to horizontal axis.\n\t * 'y' limits movement to vertical axis.\n\t * 'none' limits all movement.\n\t *\n\t * Defaults to 'both'.\n\t */\n\t axis: _react.PropTypes.oneOf(['both', 'x', 'y', 'none']),\n\t\n\t /**\n\t * `bounds` determines the range of movement available to the element.\n\t * Available values are:\n\t *\n\t * 'parent' restricts movement within the Draggable's parent node.\n\t *\n\t * Alternatively, pass an object with the following properties, all of which are optional:\n\t *\n\t * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n\t *\n\t * All values are in px.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
Content
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t bounds: _react.PropTypes.oneOfType([_react.PropTypes.shape({\n\t left: _react.PropTypes.number,\n\t right: _react.PropTypes.number,\n\t top: _react.PropTypes.number,\n\t bottom: _react.PropTypes.number\n\t }), _react.PropTypes.string, _react.PropTypes.oneOf([false])]),\n\t\n\t defaultClassName: _react.PropTypes.string,\n\t defaultClassNameDragging: _react.PropTypes.string,\n\t defaultClassNameDragged: _react.PropTypes.string,\n\t\n\t /**\n\t * `defaultPosition` specifies the x and y that the dragged item should start at\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
I start with transformX: 25px and transformY: 25px;
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t defaultPosition: _react.PropTypes.shape({\n\t x: _react.PropTypes.number,\n\t y: _react.PropTypes.number\n\t }),\n\t\n\t /**\n\t * `position`, if present, defines the current position of the element.\n\t *\n\t * This is similar to how form elements in React work - if no `position` is supplied, the component\n\t * is uncontrolled.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
I start with transformX: 25px and transformY: 25px;
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t position: _react.PropTypes.shape({\n\t x: _react.PropTypes.number,\n\t y: _react.PropTypes.number\n\t }),\n\t\n\t /**\n\t * These properties should be defined on the child, not here.\n\t */\n\t className: _shims.dontSetMe,\n\t style: _shims.dontSetMe,\n\t transform: _shims.dontSetMe\n\t});\n\tDraggable.defaultProps = _extends({}, _DraggableCore2.default.defaultProps, {\n\t axis: 'both',\n\t bounds: false,\n\t defaultClassName: 'react-draggable',\n\t defaultClassNameDragging: 'react-draggable-dragging',\n\t defaultClassNameDragged: 'react-draggable-dragged',\n\t defaultPosition: { x: 0, y: 0 },\n\t position: null\n\t});\n\texports.default = Draggable;\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_3__;\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n\t Copyright (c) 2016 Jed Watson.\n\t Licensed under the MIT License (MIT), see\n\t http://jedwatson.github.io/classnames\n\t*/\n\t/* global define */\n\t\n\t(function () {\n\t\t'use strict';\n\t\n\t\tvar hasOwn = {}.hasOwnProperty;\n\t\n\t\tfunction classNames () {\n\t\t\tvar classes = [];\n\t\n\t\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\t\tvar arg = arguments[i];\n\t\t\t\tif (!arg) continue;\n\t\n\t\t\t\tvar argType = typeof arg;\n\t\n\t\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\t\tclasses.push(arg);\n\t\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t\t} else if (argType === 'object') {\n\t\t\t\t\tfor (var key in arg) {\n\t\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn classes.join(' ');\n\t\t}\n\t\n\t\tif (typeof module !== 'undefined' && module.exports) {\n\t\t\tmodule.exports = classNames;\n\t\t} else if (true) {\n\t\t\t// register as 'classnames', consistent with npm package name\n\t\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\t\t\treturn classNames;\n\t\t\t}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t} else {\n\t\t\twindow.classNames = classNames;\n\t\t}\n\t}());\n\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _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; };\n\t\n\texports.matchesSelector = matchesSelector;\n\texports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\n\texports.addEvent = addEvent;\n\texports.removeEvent = removeEvent;\n\texports.outerHeight = outerHeight;\n\texports.outerWidth = outerWidth;\n\texports.innerHeight = innerHeight;\n\texports.innerWidth = innerWidth;\n\texports.offsetXYFromParent = offsetXYFromParent;\n\texports.createCSSTransform = createCSSTransform;\n\texports.createSVGTransform = createSVGTransform;\n\texports.getTouch = getTouch;\n\texports.getTouchIdentifier = getTouchIdentifier;\n\texports.addUserSelectStyles = addUserSelectStyles;\n\texports.removeUserSelectStyles = removeUserSelectStyles;\n\texports.styleHacks = styleHacks;\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _getPrefix = __webpack_require__(7);\n\t\n\tvar _getPrefix2 = _interopRequireDefault(_getPrefix);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _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\t\n\t/*:: import type {ControlPosition} from './types';*/\n\t\n\t\n\tvar matchesSelectorFunc = '';\n\tfunction matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/ {\n\t if (!matchesSelectorFunc) {\n\t matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t return (0, _shims.isFunction)(el[method]);\n\t });\n\t }\n\t\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t return el[matchesSelectorFunc].call(el, selector);\n\t}\n\t\n\t// Works up the tree to the draggable itself attempting to match selector.\n\tfunction matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/ {\n\t var node = el;\n\t do {\n\t if (matchesSelector(node, selector)) return true;\n\t if (node === baseNode) return false;\n\t node = node.parentNode;\n\t } while (node);\n\t\n\t return false;\n\t}\n\t\n\tfunction addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n\t if (!el) {\n\t return;\n\t }\n\t if (el.attachEvent) {\n\t el.attachEvent('on' + event, handler);\n\t } else if (el.addEventListener) {\n\t el.addEventListener(event, handler, true);\n\t } else {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t el['on' + event] = handler;\n\t }\n\t}\n\t\n\tfunction removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n\t if (!el) {\n\t return;\n\t }\n\t if (el.detachEvent) {\n\t el.detachEvent('on' + event, handler);\n\t } else if (el.removeEventListener) {\n\t el.removeEventListener(event, handler, true);\n\t } else {\n\t // $FlowIgnore: Doesn't think elements are indexable\n\t el['on' + event] = null;\n\t }\n\t}\n\t\n\tfunction outerHeight(node /*: HTMLElement*/) /*: number*/ {\n\t // This is deliberately excluding margin for our calculations, since we are using\n\t // offsetTop which is including margin. See getBoundPosition\n\t var height = node.clientHeight;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t height += (0, _shims.int)(computedStyle.borderTopWidth);\n\t height += (0, _shims.int)(computedStyle.borderBottomWidth);\n\t return height;\n\t}\n\t\n\tfunction outerWidth(node /*: HTMLElement*/) /*: number*/ {\n\t // This is deliberately excluding margin for our calculations, since we are using\n\t // offsetLeft which is including margin. See getBoundPosition\n\t var width = node.clientWidth;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t width += (0, _shims.int)(computedStyle.borderLeftWidth);\n\t width += (0, _shims.int)(computedStyle.borderRightWidth);\n\t return width;\n\t}\n\tfunction innerHeight(node /*: HTMLElement*/) /*: number*/ {\n\t var height = node.clientHeight;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t height -= (0, _shims.int)(computedStyle.paddingTop);\n\t height -= (0, _shims.int)(computedStyle.paddingBottom);\n\t return height;\n\t}\n\t\n\tfunction innerWidth(node /*: HTMLElement*/) /*: number*/ {\n\t var width = node.clientWidth;\n\t var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n\t width -= (0, _shims.int)(computedStyle.paddingLeft);\n\t width -= (0, _shims.int)(computedStyle.paddingRight);\n\t return width;\n\t}\n\t\n\t// Get from offsetParent\n\tfunction offsetXYFromParent(evt /*: {clientX: number, clientY: number}*/, offsetParent /*: HTMLElement*/) /*: ControlPosition*/ {\n\t var isBody = offsetParent === offsetParent.ownerDocument.body;\n\t var offsetParentRect = isBody ? { left: 0, top: 0 } : offsetParent.getBoundingClientRect();\n\t\n\t var x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;\n\t var y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;\n\t\n\t return { x: x, y: y };\n\t}\n\t\n\tfunction createCSSTransform(_ref) /*: Object*/ {\n\t var x = _ref.x,\n\t y = _ref.y;\n\t\n\t // Replace unitless items with px\n\t return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix2.default), 'translate(' + x + 'px,' + y + 'px)');\n\t}\n\t\n\tfunction createSVGTransform(_ref3) /*: string*/ {\n\t var x = _ref3.x,\n\t y = _ref3.y;\n\t\n\t return 'translate(' + x + ',' + y + ')';\n\t}\n\t\n\tfunction getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/ {\n\t return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n\t return identifier === t.identifier;\n\t }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n\t return identifier === t.identifier;\n\t });\n\t}\n\t\n\tfunction getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/ {\n\t if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n\t if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n\t}\n\t\n\t// User-select Hacks:\n\t//\n\t// Useful for preventing blue highlights all over everything when dragging.\n\tvar userSelectPrefix = (0, _getPrefix.getPrefix)('user-select');\n\tvar userSelect = (0, _getPrefix.browserPrefixToStyle)('user-select', userSelectPrefix);\n\tvar userSelectStyle = ';' + userSelect + ': none;';\n\tvar userSelectReplaceRegExp = new RegExp(';?' + userSelect + ': none;'); // leading ; not present on IE\n\t\n\t// Note we're passing `document` b/c we could be iframed\n\tfunction addUserSelectStyles(body /*: HTMLElement*/) {\n\t var style = body.getAttribute('style') || '';\n\t body.setAttribute('style', style + userSelectStyle);\n\t}\n\t\n\tfunction removeUserSelectStyles(body /*: HTMLElement*/) {\n\t var style = body.getAttribute('style') || '';\n\t body.setAttribute('style', style.replace(userSelectReplaceRegExp, ''));\n\t}\n\t\n\tfunction styleHacks() /*: Object*/ {\n\t var childStyle /*: Object*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\t\n\t // Workaround IE pointer events; see #51\n\t // https://github.com/mzabriskie/react-draggable/issues/51#issuecomment-103488278\n\t return _extends({\n\t touchAction: 'none'\n\t }, childStyle);\n\t}\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.findInArray = findInArray;\n\texports.isFunction = isFunction;\n\texports.isNum = isNum;\n\texports.int = int;\n\texports.dontSetMe = dontSetMe;\n\t\n\t// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\n\tfunction findInArray(array /*: Array | TouchList*/, callback /*: Function*/) /*: any*/ {\n\t for (var i = 0, length = array.length; i < length; i++) {\n\t if (callback.apply(callback, [array[i], i, array])) return array[i];\n\t }\n\t}\n\t\n\tfunction isFunction(func /*: any*/) /*: boolean*/ {\n\t return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n\t}\n\t\n\tfunction isNum(num /*: any*/) /*: boolean*/ {\n\t return typeof num === 'number' && !isNaN(num);\n\t}\n\t\n\tfunction int(a /*: string*/) /*: number*/ {\n\t return parseInt(a, 10);\n\t}\n\t\n\tfunction dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) {\n\t if (props[propName]) {\n\t return new Error('Invalid prop ' + propName + ' passed to ' + componentName + ' - do not set this, set it on the child.');\n\t }\n\t}\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.getPrefix = getPrefix;\n\texports.browserPrefixToKey = browserPrefixToKey;\n\texports.browserPrefixToStyle = browserPrefixToStyle;\n\tvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\n\tfunction getPrefix() /*: string*/ {\n\t var prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n\t\n\t // Checking specifically for 'window.document' is for pseudo-browser server-side\n\t // environments that define 'window' as the global context.\n\t // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n\t if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n\t\n\t var style = window.document.documentElement.style;\n\t\n\t if (prop in style) return '';\n\t\n\t for (var i = 0; i < prefixes.length; i++) {\n\t if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n\t }\n\t\n\t return '';\n\t}\n\t\n\tfunction browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n\t return prefix ? '' + prefix + kebabToTitleCase(prop) : prop;\n\t}\n\t\n\tfunction browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n\t return prefix ? '-' + prefix.toLowerCase() + '-' + prop : prop;\n\t}\n\t\n\tfunction kebabToTitleCase(str /*: string*/) /*: string*/ {\n\t var out = '';\n\t var shouldCapitalize = true;\n\t for (var i = 0; i < str.length; i++) {\n\t if (shouldCapitalize) {\n\t out += str[i].toUpperCase();\n\t shouldCapitalize = false;\n\t } else if (str[i] === '-') {\n\t shouldCapitalize = true;\n\t } else {\n\t out += str[i];\n\t }\n\t }\n\t return out;\n\t}\n\t\n\t// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n\t// Note that you may have to re-test for certain things; for instance, Chrome 50\n\t// can handle unprefixed `transform`, but not unprefixed `user-select`\n\texports.default = getPrefix();\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.getBoundPosition = getBoundPosition;\n\texports.snapToGrid = snapToGrid;\n\texports.canDragX = canDragX;\n\texports.canDragY = canDragY;\n\texports.getControlPosition = getControlPosition;\n\texports.createCoreData = createCoreData;\n\texports.createDraggableData = createDraggableData;\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\t/*:: import type Draggable from '../Draggable';*/\n\t/*:: import type {Bounds, ControlPosition, DraggableData} from './types';*/\n\t/*:: import type DraggableCore from '../DraggableCore';*/\n\tfunction getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/ {\n\t // If no bounds, short-circuit and move on\n\t if (!draggable.props.bounds) return [x, y];\n\t\n\t // Clone new bounds\n\t var bounds = draggable.props.bounds;\n\t\n\t bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n\t var node = _reactDom2.default.findDOMNode(draggable);\n\t\n\t if (typeof bounds === 'string') {\n\t var ownerDocument = node.ownerDocument;\n\t\n\t var ownerWindow = ownerDocument.defaultView;\n\t var boundNode = void 0;\n\t if (bounds === 'parent') {\n\t boundNode = node.parentNode;\n\t } else {\n\t boundNode = ownerDocument.querySelector(bounds);\n\t if (!boundNode) throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n\t }\n\t var nodeStyle = ownerWindow.getComputedStyle(node);\n\t var boundNodeStyle = ownerWindow.getComputedStyle(boundNode);\n\t // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n\t bounds = {\n\t left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.borderLeftWidth) + (0, _shims.int)(nodeStyle.marginLeft),\n\t top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.borderTopWidth) + (0, _shims.int)(nodeStyle.marginTop),\n\t right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft,\n\t bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop\n\t };\n\t }\n\t\n\t // Keep x and y below right and bottom limits...\n\t if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n\t if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\t\n\t // But above left and top limits.\n\t if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n\t if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n\t\n\t return [x, y];\n\t}\n\t\n\tfunction snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/ {\n\t var x = Math.round(pendingX / grid[0]) * grid[0];\n\t var y = Math.round(pendingY / grid[1]) * grid[1];\n\t return [x, y];\n\t}\n\t\n\tfunction canDragX(draggable /*: Draggable*/) /*: boolean*/ {\n\t return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n\t}\n\t\n\tfunction canDragY(draggable /*: Draggable*/) /*: boolean*/ {\n\t return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n\t}\n\t\n\t// Get {x, y} positions from event.\n\tfunction getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/ {\n\t var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n\t if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n\t var node = _reactDom2.default.findDOMNode(draggableCore);\n\t // User can provide an offsetParent if desired.\n\t var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n\t return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent);\n\t}\n\t\n\t// Create an data object exposed by 's events\n\tfunction createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/ {\n\t var state = draggable.state;\n\t var isStart = !(0, _shims.isNum)(state.lastX);\n\t\n\t if (isStart) {\n\t // If this is our first move, use the x and y as last coords.\n\t return {\n\t node: _reactDom2.default.findDOMNode(draggable),\n\t deltaX: 0, deltaY: 0,\n\t lastX: x, lastY: y,\n\t x: x, y: y\n\t };\n\t } else {\n\t // Otherwise calculate proper values.\n\t return {\n\t node: _reactDom2.default.findDOMNode(draggable),\n\t deltaX: x - state.lastX, deltaY: y - state.lastY,\n\t lastX: state.lastX, lastY: state.lastY,\n\t x: x, y: y\n\t };\n\t }\n\t}\n\t\n\t// Create an data exposed by 's events\n\tfunction createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/ {\n\t return {\n\t node: coreData.node,\n\t x: draggable.state.x + coreData.deltaX,\n\t y: draggable.state.y + coreData.deltaY,\n\t deltaX: coreData.deltaX,\n\t deltaY: coreData.deltaY,\n\t lastX: draggable.state.x,\n\t lastY: draggable.state.y\n\t };\n\t}\n\t\n\t// A lot faster than stringify/parse\n\tfunction cloneBounds(bounds /*: Bounds*/) /*: Bounds*/ {\n\t return {\n\t left: bounds.left,\n\t top: bounds.top,\n\t right: bounds.right,\n\t bottom: bounds.bottom\n\t };\n\t}\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_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\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\t\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _react = __webpack_require__(2);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _reactDom = __webpack_require__(3);\n\t\n\tvar _reactDom2 = _interopRequireDefault(_reactDom);\n\t\n\tvar _domFns = __webpack_require__(5);\n\t\n\tvar _positionFns = __webpack_require__(8);\n\t\n\tvar _shims = __webpack_require__(6);\n\t\n\tvar _log = __webpack_require__(11);\n\t\n\tvar _log2 = _interopRequireDefault(_log);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\t// Simple abstraction for dragging events names.\n\t/*:: import type {EventHandler} from './utils/types';*/\n\tvar eventsFor = {\n\t touch: {\n\t start: 'touchstart',\n\t move: 'touchmove',\n\t stop: 'touchend'\n\t },\n\t mouse: {\n\t start: 'mousedown',\n\t move: 'mousemove',\n\t stop: 'mouseup'\n\t }\n\t};\n\t\n\t// Default to mouse events.\n\tvar dragEventFor = eventsFor.mouse;\n\t\n\t//\n\t// Define .\n\t//\n\t// is for advanced usage of . It maintains minimal internal state so it can\n\t// work well with libraries that require more control over the element.\n\t//\n\t\n\t/*:: type CoreState = {\n\t dragging: boolean,\n\t lastX: number,\n\t lastY: number,\n\t touchIdentifier: ?number\n\t};*/\n\t\n\tvar DraggableCore = function (_React$Component) {\n\t _inherits(DraggableCore, _React$Component);\n\t\n\t function DraggableCore() {\n\t var _ref;\n\t\n\t var _temp, _this, _ret;\n\t\n\t _classCallCheck(this, DraggableCore);\n\t\n\t for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n\t args[_key] = arguments[_key];\n\t }\n\t\n\t return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = DraggableCore.__proto__ || Object.getPrototypeOf(DraggableCore)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n\t dragging: false,\n\t // Used while dragging to determine deltas.\n\t lastX: NaN, lastY: NaN,\n\t touchIdentifier: null\n\t }, _this.handleDragStart = function (e) {\n\t // Make it possible to attach event handlers on top of this one.\n\t _this.props.onMouseDown(e);\n\t\n\t // Only accept left-clicks.\n\t if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\t\n\t // Get nodes. Be sure to grab relative document (could be iframed)\n\t var domNode = _reactDom2.default.findDOMNode(_this);\n\t var ownerDocument = domNode.ownerDocument;\n\t\n\t // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\t\n\t if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, domNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, domNode)) {\n\t return;\n\t }\n\t\n\t // Set touch identifier in component state if this is a touch event. This allows us to\n\t // distinguish between individual touches on multitouch screens by identifying which\n\t // touchpoint was set to this element.\n\t var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n\t _this.setState({ touchIdentifier: touchIdentifier });\n\t\n\t // Get the current drag point from the event. This is used as the offset.\n\t var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _this);\n\t if (position == null) return; // not possible but satisfies flow\n\t var x = position.x,\n\t y = position.y;\n\t\n\t // Create an event object with all the data parents need to make a decision here.\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t (0, _log2.default)('DraggableCore: handleDragStart: %j', coreEvent);\n\t\n\t // Call event handler. If it returns explicit false, cancel.\n\t (0, _log2.default)('calling', _this.props.onStart);\n\t var shouldUpdate = _this.props.onStart(e, coreEvent);\n\t if (shouldUpdate === false) return;\n\t\n\t // Add a style to the body to disable user-select. This prevents text from\n\t // being selected all over the page.\n\t if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument.body);\n\t\n\t // Initiate dragging. Set the current x and y as offsets\n\t // so we know how much we've moved during the drag. This allows us\n\t // to drag elements around even if they have been moved, without issue.\n\t _this.setState({\n\t dragging: true,\n\t\n\t lastX: x,\n\t lastY: y\n\t });\n\t\n\t // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n\t // this element. We use different events depending on whether or not we have detected that this\n\t // is a touch-capable device.\n\t (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n\t (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n\t }, _this.handleDrag = function (e) {\n\t\n\t // Prevent scrolling on mobile devices, like ipad/iphone.\n\t if (e.type === 'touchmove') e.preventDefault();\n\t\n\t // Get the current drag point from the event. This is used as the offset.\n\t var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n\t if (position == null) return;\n\t var x = position.x,\n\t y = position.y;\n\t\n\t // Snap to grid if prop has been provided\n\t\n\t if (x !== x) debugger;\n\t\n\t if (Array.isArray(_this.props.grid)) {\n\t var deltaX = x - _this.state.lastX,\n\t deltaY = y - _this.state.lastY;\n\t\n\t var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);\n\t\n\t var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\t\n\t deltaX = _snapToGrid2[0];\n\t deltaY = _snapToGrid2[1];\n\t\n\t if (!deltaX && !deltaY) return; // skip useless drag\n\t x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;\n\t }\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t (0, _log2.default)('DraggableCore: handleDrag: %j', coreEvent);\n\t\n\t // Call event handler. If it returns explicit false, trigger end.\n\t var shouldUpdate = _this.props.onDrag(e, coreEvent);\n\t if (shouldUpdate === false) {\n\t try {\n\t // $FlowIgnore\n\t _this.handleDragStop(new MouseEvent('mouseup'));\n\t } catch (err) {\n\t // Old browsers\n\t var event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);\n\t // I see why this insanity was deprecated\n\t // $FlowIgnore\n\t event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n\t _this.handleDragStop(event);\n\t }\n\t return;\n\t }\n\t\n\t _this.setState({\n\t lastX: x,\n\t lastY: y\n\t });\n\t }, _this.handleDragStop = function (e) {\n\t if (!_this.state.dragging) return;\n\t\n\t var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n\t if (position == null) return;\n\t var x = position.x,\n\t y = position.y;\n\t\n\t var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\t\n\t var _ReactDOM$findDOMNode = _reactDom2.default.findDOMNode(_this),\n\t ownerDocument = _ReactDOM$findDOMNode.ownerDocument;\n\t\n\t // Remove user-select hack\n\t\n\t\n\t if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument.body);\n\t\n\t (0, _log2.default)('DraggableCore: handleDragStop: %j', coreEvent);\n\t\n\t // Reset the el.\n\t _this.setState({\n\t dragging: false,\n\t lastX: NaN,\n\t lastY: NaN\n\t });\n\t\n\t // Call event handler\n\t _this.props.onStop(e, coreEvent);\n\t\n\t // Remove event handlers\n\t (0, _log2.default)('DraggableCore: Removing handlers');\n\t (0, _domFns.removeEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n\t }, _this.onMouseDown = function (e) {\n\t dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\t\n\t return _this.handleDragStart(e);\n\t }, _this.onMouseUp = function (e) {\n\t dragEventFor = eventsFor.mouse;\n\t\n\t return _this.handleDragStop(e);\n\t }, _this.onTouchStart = function (e) {\n\t // We're on a touch device now, so change the event handlers\n\t dragEventFor = eventsFor.touch;\n\t\n\t return _this.handleDragStart(e);\n\t }, _this.onTouchEnd = function (e) {\n\t // We're on a touch device now, so change the event handlers\n\t dragEventFor = eventsFor.touch;\n\t\n\t return _this.handleDragStop(e);\n\t }, _temp), _possibleConstructorReturn(_this, _ret);\n\t }\n\t\n\t _createClass(DraggableCore, [{\n\t key: 'componentWillUnmount',\n\t value: function componentWillUnmount() {\n\t // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n\t // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n\t var _ReactDOM$findDOMNode2 = _reactDom2.default.findDOMNode(this),\n\t ownerDocument = _ReactDOM$findDOMNode2.ownerDocument;\n\t\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n\t (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n\t if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument.body);\n\t }\n\t\n\t // Same as onMouseDown (start drag), but now consider this a touch device.\n\t\n\t }, {\n\t key: 'render',\n\t value: function render() /*: React.Element*/ {\n\t // Reuse the child provided\n\t // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\t return _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n\t style: (0, _domFns.styleHacks)(this.props.children.props.style),\n\t\n\t // Note: mouseMove handler is attached to document so it will still function\n\t // when the user drags quickly and leaves the bounds of the element.\n\t onMouseDown: this.onMouseDown,\n\t onTouchStart: this.onTouchStart,\n\t onMouseUp: this.onMouseUp,\n\t onTouchEnd: this.onTouchEnd\n\t });\n\t }\n\t }]);\n\t\n\t return DraggableCore;\n\t}(_react2.default.Component);\n\t\n\tDraggableCore.displayName = 'DraggableCore';\n\tDraggableCore.propTypes = {\n\t /**\n\t * `allowAnyClick` allows dragging using any mouse button.\n\t * By default, we only accept the left button.\n\t *\n\t * Defaults to `false`.\n\t */\n\t allowAnyClick: _react.PropTypes.bool,\n\t\n\t /**\n\t * `disabled`, if true, stops the from dragging. All handlers,\n\t * with the exception of `onMouseDown`, will not fire.\n\t */\n\t disabled: _react.PropTypes.bool,\n\t\n\t /**\n\t * By default, we add 'user-select:none' attributes to the document body\n\t * to prevent ugly text selection during drag. If this is causing problems\n\t * for your app, set this to `false`.\n\t */\n\t enableUserSelectHack: _react.PropTypes.bool,\n\t\n\t /**\n\t * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n\t * instead of using the parent node.\n\t */\n\t offsetParent: function offsetParent(props, propName) {\n\t if (process.browser && props[propName] && props[propName].nodeType !== 1) {\n\t throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n\t }\n\t },\n\t\n\t /**\n\t * `grid` specifies the x and y that dragging should snap to.\n\t */\n\t grid: _react.PropTypes.arrayOf(_react.PropTypes.number),\n\t\n\t /**\n\t * `handle` specifies a selector to be used as the handle that initiates drag.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return (\n\t * \n\t *
\n\t *
Click me to drag
\n\t *
This is some other content
\n\t *
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t handle: _react.PropTypes.string,\n\t\n\t /**\n\t * `cancel` specifies a selector to be used to prevent drag initialization.\n\t *\n\t * Example:\n\t *\n\t * ```jsx\n\t * let App = React.createClass({\n\t * render: function () {\n\t * return(\n\t * \n\t *
\n\t *
You can't drag from here
\n\t *
Dragging here works fine
\n\t *
\n\t * \n\t * );\n\t * }\n\t * });\n\t * ```\n\t */\n\t cancel: _react.PropTypes.string,\n\t\n\t /**\n\t * Called when dragging starts.\n\t * If this function returns the boolean false, dragging will be canceled.\n\t */\n\t onStart: _react.PropTypes.func,\n\t\n\t /**\n\t * Called while dragging.\n\t * If this function returns the boolean false, dragging will be canceled.\n\t */\n\t onDrag: _react.PropTypes.func,\n\t\n\t /**\n\t * Called when dragging stops.\n\t * If this function returns the boolean false, the drag will remain active.\n\t */\n\t onStop: _react.PropTypes.func,\n\t\n\t /**\n\t * A workaround option which can be passed if onMouseDown needs to be accessed,\n\t * since it'll always be blocked (as there is internal use of onMouseDown)\n\t */\n\t onMouseDown: _react.PropTypes.func,\n\t\n\t /**\n\t * These properties should be defined on the child, not here.\n\t */\n\t className: _shims.dontSetMe,\n\t style: _shims.dontSetMe,\n\t transform: _shims.dontSetMe\n\t};\n\tDraggableCore.defaultProps = {\n\t allowAnyClick: false, // by default only accept left click\n\t cancel: null,\n\t disabled: false,\n\t enableUserSelectHack: true,\n\t offsetParent: null,\n\t handle: null,\n\t grid: null,\n\t transform: null,\n\t onStart: function onStart() {},\n\t onDrag: function onDrag() {},\n\t onStop: function onStop() {},\n\t onMouseDown: function onMouseDown() {}\n\t};\n\texports.default = DraggableCore;\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10)))\n\n/***/ },\n/* 10 */\n/***/ function(module, exports) {\n\n\t// shim for using process in browser\n\tvar process = module.exports = {};\n\t\n\t// cached from whatever global is present so that test runners that stub it\n\t// don't break things. But we need to wrap it in a try catch in case it is\n\t// wrapped in strict mode code which doesn't define any globals. It's inside a\n\t// function because try/catches deoptimize in certain engines.\n\t\n\tvar cachedSetTimeout;\n\tvar cachedClearTimeout;\n\t\n\tfunction defaultSetTimout() {\n\t throw new Error('setTimeout has not been defined');\n\t}\n\tfunction defaultClearTimeout () {\n\t throw new Error('clearTimeout has not been defined');\n\t}\n\t(function () {\n\t try {\n\t if (typeof setTimeout === 'function') {\n\t cachedSetTimeout = setTimeout;\n\t } else {\n\t cachedSetTimeout = defaultSetTimout;\n\t }\n\t } catch (e) {\n\t cachedSetTimeout = defaultSetTimout;\n\t }\n\t try {\n\t if (typeof clearTimeout === 'function') {\n\t cachedClearTimeout = clearTimeout;\n\t } else {\n\t cachedClearTimeout = defaultClearTimeout;\n\t }\n\t } catch (e) {\n\t cachedClearTimeout = defaultClearTimeout;\n\t }\n\t} ())\n\tfunction runTimeout(fun) {\n\t if (cachedSetTimeout === setTimeout) {\n\t //normal enviroments in sane situations\n\t return setTimeout(fun, 0);\n\t }\n\t // if setTimeout wasn't available but was latter defined\n\t if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t cachedSetTimeout = setTimeout;\n\t return setTimeout(fun, 0);\n\t }\n\t try {\n\t // when when somebody has screwed with setTimeout but no I.E. maddness\n\t return cachedSetTimeout(fun, 0);\n\t } catch(e){\n\t try {\n\t // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t return cachedSetTimeout.call(null, fun, 0);\n\t } catch(e){\n\t // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n\t return cachedSetTimeout.call(this, fun, 0);\n\t }\n\t }\n\t\n\t\n\t}\n\tfunction runClearTimeout(marker) {\n\t if (cachedClearTimeout === clearTimeout) {\n\t //normal enviroments in sane situations\n\t return clearTimeout(marker);\n\t }\n\t // if clearTimeout wasn't available but was latter defined\n\t if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t cachedClearTimeout = clearTimeout;\n\t return clearTimeout(marker);\n\t }\n\t try {\n\t // when when somebody has screwed with setTimeout but no I.E. maddness\n\t return cachedClearTimeout(marker);\n\t } catch (e){\n\t try {\n\t // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t return cachedClearTimeout.call(null, marker);\n\t } catch (e){\n\t // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n\t // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t return cachedClearTimeout.call(this, marker);\n\t }\n\t }\n\t\n\t\n\t\n\t}\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\t\n\tfunction cleanUpNextTick() {\n\t if (!draining || !currentQueue) {\n\t return;\n\t }\n\t draining = false;\n\t if (currentQueue.length) {\n\t queue = currentQueue.concat(queue);\n\t } else {\n\t queueIndex = -1;\n\t }\n\t if (queue.length) {\n\t drainQueue();\n\t }\n\t}\n\t\n\tfunction drainQueue() {\n\t if (draining) {\n\t return;\n\t }\n\t var timeout = runTimeout(cleanUpNextTick);\n\t draining = true;\n\t\n\t var len = queue.length;\n\t while(len) {\n\t currentQueue = queue;\n\t queue = [];\n\t while (++queueIndex < len) {\n\t if (currentQueue) {\n\t currentQueue[queueIndex].run();\n\t }\n\t }\n\t queueIndex = -1;\n\t len = queue.length;\n\t }\n\t currentQueue = null;\n\t draining = false;\n\t runClearTimeout(timeout);\n\t}\n\t\n\tprocess.nextTick = function (fun) {\n\t var args = new Array(arguments.length - 1);\n\t if (arguments.length > 1) {\n\t for (var i = 1; i < arguments.length; i++) {\n\t args[i - 1] = arguments[i];\n\t }\n\t }\n\t queue.push(new Item(fun, args));\n\t if (queue.length === 1 && !draining) {\n\t runTimeout(drainQueue);\n\t }\n\t};\n\t\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t this.fun = fun;\n\t this.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t this.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\t\n\tfunction noop() {}\n\t\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\t\n\tprocess.binding = function (name) {\n\t throw new Error('process.binding is not supported');\n\t};\n\t\n\tprocess.cwd = function () { return '/' };\n\tprocess.chdir = function (dir) {\n\t throw new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function() { return 0; };\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.default = log;\n\t\n\t/*eslint no-console:0*/\n\tfunction log() {\n\t var _console;\n\t\n\t if ((undefined)) (_console = console).log.apply(_console, arguments);\n\t}\n\n/***/ }\n/******/ ])\n});\n;\n//# sourceMappingURL=react-draggable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-draggable/dist/react-draggable.js\n// module id = 7\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDraggable = require('react-draggable');\n\nvar _cloneElement = require('./cloneElement');\n\nvar _cloneElement2 = _interopRequireDefault(_cloneElement);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/*:: export type Props = {\n children: React.Element,\n width: number,\n height: number,\n handleSize: [number, number],\n lockAspectRatio: boolean,\n axis: Axis,\n minConstraints: [number, number],\n maxConstraints: [number, number],\n onResizeStop?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n onResizeStart?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n onResize?: ?(e: SyntheticEvent, data: ResizeCallbackData) => any,\n draggableOpts?: ?Object\n};*/\n/*:: type Axis = 'both' | 'x' | 'y' | 'none';*/\n/*:: type Position = {\n\n};*/\n/*:: type State = {\n resizing: boolean,\n width: number, height: number,\n slackW: number, slackH: number\n};*/\n/*:: type DragCallbackData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number\n};*/\n/*:: type ResizeCallbackData = {\n node: HTMLElement,\n size: {width: number, height: number}\n};*/\n\nvar Resizable = function (_React$Component) {\n _inherits(Resizable, _React$Component);\n\n function Resizable() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, Resizable);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n resizing: false,\n width: _this.props.width, height: _this.props.height,\n slackW: 0, slackH: 0\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n Resizable.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps /*: Object*/) {\n // If parent changes height/width, set that in our state.\n if (!this.state.resizing && (nextProps.width !== this.props.width || nextProps.height !== this.props.height)) {\n this.setState({\n width: nextProps.width,\n height: nextProps.height\n });\n }\n };\n\n Resizable.prototype.lockAspectRatio = function lockAspectRatio(width /*: number*/, height /*: number*/, aspectRatio /*: number*/) /*: [number, number]*/ {\n height = width / aspectRatio;\n width = height * aspectRatio;\n return [width, height];\n };\n\n // If you do this, be careful of constraints\n\n\n Resizable.prototype.runConstraints = function runConstraints(width /*: number*/, height /*: number*/) /*: [number, number]*/ {\n var _ref = [this.props.minConstraints, this.props.maxConstraints],\n min = _ref[0],\n max = _ref[1];\n\n\n if (this.props.lockAspectRatio) {\n var ratio = this.state.width / this.state.height;\n height = width / ratio;\n width = height * ratio;\n }\n\n if (!min && !max) return [width, height];\n\n var oldW = width,\n oldH = height;\n\n // 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 _state = this.state,\n slackW = _state.slackW,\n slackH = _state.slackH;\n\n width += slackW;\n height += slackH;\n\n if (min) {\n width = Math.max(min[0], width);\n height = Math.max(min[1], height);\n }\n if (max) {\n width = Math.min(max[0], width);\n height = Math.min(max[1], height);\n }\n\n // If the numbers changed, we must have introduced some slack. Record it for the next iteration.\n slackW += oldW - width;\n slackH += oldH - height;\n if (slackW !== this.state.slackW || slackH !== this.state.slackH) {\n this.setState({ slackW: slackW, slackH: slackH });\n }\n\n return [width, height];\n };\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 Resizable.prototype.resizeHandler = function resizeHandler(handlerName /*: string*/) /*: Function*/ {\n var _this2 = this;\n\n return function (e /*: SyntheticEvent | MouseEvent*/, _ref2) {\n var node = _ref2.node,\n deltaX = _ref2.deltaX,\n deltaY = _ref2.deltaY;\n\n\n // Axis restrictions\n var canDragX = _this2.props.axis === 'both' || _this2.props.axis === 'x';\n var canDragY = _this2.props.axis === 'both' || _this2.props.axis === 'y';\n\n // Update w/h\n var width = _this2.state.width + (canDragX ? deltaX : 0);\n var height = _this2.state.height + (canDragY ? deltaY : 0);\n\n // Early return if no change\n var widthChanged = width !== _this2.state.width,\n heightChanged = height !== _this2.state.height;\n if (handlerName === 'onResize' && !widthChanged && !heightChanged) return;\n\n // Set the appropriate state for this handler.\n var _runConstraints = _this2.runConstraints(width, height);\n\n width = _runConstraints[0];\n height = _runConstraints[1];\n var newState = {};\n if (handlerName === 'onResizeStart') {\n newState.resizing = true;\n } else if (handlerName === 'onResizeStop') {\n newState.resizing = false;\n newState.slackW = newState.slackH = 0;\n } else {\n // Early return if no change after constraints\n if (width === _this2.state.width && height === _this2.state.height) return;\n newState.width = width;\n newState.height = height;\n }\n\n var hasCb = typeof _this2.props[handlerName] === 'function';\n if (hasCb) {\n if (typeof e.persist === 'function') e.persist();\n _this2.setState(newState, function () {\n return _this2.props[handlerName](e, { node: node, size: { width: width, height: height } });\n });\n } else {\n _this2.setState(newState);\n }\n };\n };\n\n Resizable.prototype.render = function render() /*: React.Element*/ {\n // eslint-disable-next-line no-unused-vars\n var _props = this.props,\n children = _props.children,\n draggableOpts = _props.draggableOpts,\n width = _props.width,\n height = _props.height,\n handleSize = _props.handleSize,\n lockAspectRatio = _props.lockAspectRatio,\n axis = _props.axis,\n minConstraints = _props.minConstraints,\n maxConstraints = _props.maxConstraints,\n onResize = _props.onResize,\n onResizeStop = _props.onResizeStop,\n onResizeStart = _props.onResizeStart,\n p = _objectWithoutProperties(_props, ['children', 'draggableOpts', 'width', 'height', 'handleSize', 'lockAspectRatio', 'axis', 'minConstraints', 'maxConstraints', 'onResize', 'onResizeStop', 'onResizeStart']);\n\n var className = p.className ? p.className + ' react-resizable' : 'react-resizable';\n\n // 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 // Its original children (resizable's child's children), and\n // A draggable handle.\n return (0, _cloneElement2.default)(children, _extends({}, p, {\n className: className,\n children: [children.props.children, _react2.default.createElement(\n _reactDraggable.DraggableCore,\n _extends({}, draggableOpts, {\n key: 'resizableHandle',\n onStop: this.resizeHandler('onResizeStop'),\n onStart: this.resizeHandler('onResizeStart'),\n onDrag: this.resizeHandler('onResize')\n }),\n _react2.default.createElement('span', { className: 'react-resizable-handle' })\n )]\n }));\n };\n\n return Resizable;\n}(_react2.default.Component);\n\nResizable.propTypes = {\n //\n // Required Props\n //\n\n // Require that one and only one child be present.\n children: _react.PropTypes.element.isRequired,\n\n // Initial w/h\n width: _react.PropTypes.number.isRequired,\n height: _react.PropTypes.number.isRequired,\n\n //\n // Optional props\n //\n\n // If you change this, be sure to update your css\n handleSize: _react.PropTypes.array,\n\n // If true, will only allow width/height to move in lockstep\n lockAspectRatio: _react.PropTypes.bool,\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 axis: _react.PropTypes.oneOf(['both', 'x', 'y', 'none']),\n\n // Min/max size\n minConstraints: _react.PropTypes.arrayOf(_react.PropTypes.number),\n maxConstraints: _react.PropTypes.arrayOf(_react.PropTypes.number),\n\n // Callbacks\n onResizeStop: _react.PropTypes.func,\n onResizeStart: _react.PropTypes.func,\n onResize: _react.PropTypes.func,\n\n // These will be passed wholesale to react-draggable's DraggableCore\n draggableOpts: _react.PropTypes.object\n};\nResizable.defaultProps = {\n handleSize: [20, 20],\n lockAspectRatio: false,\n axis: 'both',\n minConstraints: [20, 20],\n maxConstraints: [Infinity, Infinity]\n};\nexports.default = Resizable;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-resizable/build/Resizable.js\n// module id = 8\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_9__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}\n// module id = 9\n// module chunks = 0","// @flow\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport isEqual from 'lodash.isequal';\n\nimport {cloneLayout, synchronizeLayoutWithChildren, validateLayout} from './utils';\nimport {getBreakpointFromWidth, getColsFromBreakpoint, findOrGenerateResponsiveLayout} from './responsiveUtils';\nimport ReactGridLayout from './ReactGridLayout';\n\nconst noop = function(){};\nconst type = (obj) => Object.prototype.toString.call(obj);\n\nimport type {Layout} from './utils';\ntype State = {\n layout: Layout,\n breakpoint: string,\n cols: number\n};\n\nexport default class ResponsiveReactGridLayout extends React.Component {\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 //\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 // # of cols. This is a breakpoint -> cols map\n cols: PropTypes.object,\n\n // layouts is an object mapping breakpoints to layouts.\n // e.g. {lg: Layout, md: Layout, ...}\n layouts(props, propName) {\n if (type(props[propName]) !== '[object Object]') {\n throw new Error('Layout property must be an object. Received: ' + type(props[propName]));\n }\n Object.keys(props[propName]).forEach((key) => {\n if (!(key in props.breakpoints)) {\n throw new Error('Each key in layouts must align with a key in breakpoints.');\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 = {\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 layouts: {},\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, verticalCompact, cols} = this.props;\n const breakpoint = getBreakpointFromWidth(breakpoints, width);\n const colNo = getColsFromBreakpoint(breakpoint, cols);\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(layouts, breakpoints, breakpoint,\n breakpoint, colNo, verticalCompact);\n\n return {\n layout: initialLayout,\n breakpoint: breakpoint,\n cols: colNo\n };\n }\n\n componentWillReceiveProps(nextProps: Object) {\n\n // Allow parent to set width or breakpoint directly.\n if (\n nextProps.width != this.props.width\n || nextProps.breakpoint !== this.props.breakpoint\n || !isEqual(nextProps.breakpoints, this.props.breakpoints)\n || !isEqual(nextProps.cols, this.props.cols)\n ) {\n this.onWidthChange(nextProps);\n }\n\n // Allow parent to set layouts directly.\n else if (!isEqual(nextProps.layouts, this.props.layouts)) {\n const {breakpoint, cols} = this.state;\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, nextProps.breakpoints,\n breakpoint, breakpoint, cols, nextProps.verticalCompact\n );\n this.setState({layout: newLayout});\n }\n }\n\n // wrap layouts so we do not need to pass layouts to child\n onLayoutChange = (layout: Layout) => {\n this.props.onLayoutChange(layout, {...this.props.layouts, [this.state.breakpoint]: layout});\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(nextProps: typeof ResponsiveReactGridLayout.prototype.props) {\n const {breakpoints, cols, layouts, verticalCompact} = nextProps;\n const newBreakpoint = nextProps.breakpoint || getBreakpointFromWidth(nextProps.breakpoints, nextProps.width);\n\n const lastBreakpoint = this.state.breakpoint;\n\n // Breakpoint change\n if (lastBreakpoint !== newBreakpoint || this.props.breakpoints !== breakpoints || this.props.cols !== cols) {\n // Preserve the current layout if the current breakpoint is not present in the next layouts.\n if (!(lastBreakpoint in layouts)) layouts[lastBreakpoint] = cloneLayout(this.state.layout);\n\n // Find or generate a new layout.\n const newCols: number = getColsFromBreakpoint(newBreakpoint, cols);\n let layout = findOrGenerateResponsiveLayout(layouts, breakpoints, newBreakpoint,\n lastBreakpoint, newCols, verticalCompact);\n\n // This adds missing items.\n layout = synchronizeLayoutWithChildren(layout, nextProps.children, newCols, verticalCompact);\n\n // Store the new layout.\n layouts[newBreakpoint] = layout;\n\n // callbacks\n this.props.onLayoutChange(layout, layouts);\n this.props.onBreakpointChange(newBreakpoint, newCols);\n this.props.onWidthChange(nextProps.width, nextProps.margin, newCols, nextProps.containerPadding);\n\n this.setState({breakpoint: newBreakpoint, layout: layout, cols: newCols});\n }\n }\n\n render() {\n // eslint-disable-next-line no-unused-vars\n const {breakpoint, breakpoints, cols, layouts, onBreakpointChange, onLayoutChange, onWidthChange,\n ...other} = this.props;\n\n return (\n \n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/ResponsiveReactGridLayout.jsx","// @flow\nimport React from \"react\";\nimport PropTypes from 'prop-types';\nimport ReactDOM from 'react-dom';\n\ntype State = {\n width: number\n};\n\n/*\n * A simple HOC that provides facility for listening to container resizes.\n */\ntype ProviderT = (ComposedComponent: ReactClass) => ReactClass;\nconst WidthProvider: ProviderT = (ComposedComponent) => class extends React.Component {\n\n static defaultProps = {\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: State = {\n width: 1280\n };\n\n mounted: boolean = false;\n\n componentDidMount() {\n this.mounted = true;\n\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 = (_event: ?Event) => {\n if (!this.mounted) return;\n const node = ReactDOM.findDOMNode(this); // Flow casts this to Text | Element\n if (node instanceof HTMLElement) this.setState({width: node.offsetWidth});\n }\n\n render() {\n if (this.props.measureBeforeMount && !this.mounted) {\n return ;\n }\n\n return ;\n }\n};\n\nexport default WidthProvider;\n\n\n\n// WEBPACK FOOTER //\n// ./lib/components/WidthProvider.jsx","// @flow\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport {DraggableCore} from 'react-draggable';\nimport {Resizable} from 'react-resizable';\nimport {perc, setTopLeft, setTransform} from './utils';\nimport classNames from 'classnames';\n\nimport type {DragCallbackData, Position} from './utils';\n\ntype State = {\n resizing: ?{width: number, height: number},\n dragging: ?{top: number, left: number},\n className: string\n};\n\n/**\n * An individual item within a ReactGridLayout.\n */\nexport default class GridItem extends React.Component {\n\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, propName) {\n const value = props[propName];\n if (typeof value !== 'number') return new Error('minWidth not Number');\n if (value > props.w || value > props.maxW) return new Error('minWidth larger than item width/maxWidth');\n },\n\n maxW: function (props, propName) {\n const value = props[propName];\n if (typeof value !== 'number') return new Error('maxWidth not Number');\n if (value < props.w || value < props.minW) return new Error('maxWidth smaller than item width/minWidth');\n },\n\n minH: function (props, propName) {\n const value = props[propName];\n if (typeof value !== 'number') return new Error('minHeight not Number');\n if (value > props.h || value > props.maxH) return new Error('minHeight larger than item height/maxHeight');\n },\n\n maxH: function (props, propName) {\n const value = props[propName];\n if (typeof value !== 'number') return new Error('maxHeight not Number');\n if (value < props.h || value < props.minH) 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 // 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 static: PropTypes.bool,\n\n // Use CSS transforms instead of top/left\n useCSSTransforms: PropTypes.bool.isRequired,\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 };\n\n static defaultProps = {\n className: '',\n cancel: '',\n minH: 1,\n minW: 1,\n maxH: Infinity,\n maxW: Infinity\n };\n\n state: State = {\n resizing: null,\n dragging: null,\n className: ''\n };\n\n // Helper for generating column width\n calcColWidth(): number {\n const {margin, containerPadding, containerWidth, cols} = this.props;\n return (containerWidth - (margin[0] * (cols - 1)) - (containerPadding[0] * 2)) / cols;\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 {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 {Object} Object containing coords.\n */\n calcPosition(x: number, y: number, w: number, h: number, state: ?Object): Position {\n const {margin, containerPadding, rowHeight} = this.props;\n const colWidth = this.calcColWidth();\n\n const out = {\n left: Math.round((colWidth + margin[0]) * x + containerPadding[0]),\n top: Math.round((rowHeight + margin[1]) * y + containerPadding[1]),\n // 0 * Infinity === NaN, which causes problems with resize constraints;\n // Fix this if it occurs.\n // Note we do it here rather than later because Math.round(Infinity) causes deopt\n width: w === Infinity ? w : Math.round(colWidth * w + Math.max(0, w - 1) * margin[0]),\n height: h === Infinity ? h : Math.round(rowHeight * h + Math.max(0, h - 1) * margin[1])\n };\n\n if (state && state.resizing) {\n out.width = Math.round(state.resizing.width);\n out.height = Math.round(state.resizing.height);\n }\n\n if (state && state.dragging) {\n out.top = Math.round(state.dragging.top);\n out.left = Math.round(state.dragging.left);\n }\n\n return out;\n }\n\n /**\n * Translate x and y coordinates from pixels to grid units.\n * @param {Number} top Top position (relative to parent) in pixels.\n * @param {Number} left Left position (relative to parent) in pixels.\n * @return {Object} x and y in grid units.\n */\n calcXY(top: number, left: number): {x: number, y: number} {\n const {margin, cols, rowHeight, w, h, maxRows} = this.props;\n const colWidth = this.calcColWidth();\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 = Math.max(Math.min(x, cols - w), 0);\n y = Math.max(Math.min(y, maxRows - h), 0);\n\n return {x, y};\n }\n\n /**\n * Given a height and width in pixel values, calculate grid units.\n * @param {Number} height Height in pixels.\n * @param {Number} width Width in pixels.\n * @return {Object} w, h as grid units.\n */\n calcWH({height, width}: {height: number, width: number}): {w: number, h: number} {\n const {margin, maxRows, cols, rowHeight, x, y} = this.props;\n const colWidth = this.calcColWidth();\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 = Math.max(Math.min(w, cols - x), 0);\n h = Math.max(Math.min(h, maxRows - y), 0);\n return {w, h};\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 }\n // top,left (slow)\n else {\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(child: React.Element): React.Element {\n return (\n \n {child}\n \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(child: React.Element, position: Position): React.Element {\n const {cols, x, minW, minH, maxW, maxH} = this.props;\n\n // This is the max possible width - doesn't go to infinity because of the width of the window\n const maxWidth = this.calcPosition(0, 0, cols - x, 0).width;\n\n // Calculate min/max constraints using our min & maxes\n const mins = this.calcPosition(0, 0, minW, minH);\n const maxes = this.calcPosition(0, 0, maxW, maxH);\n const minConstraints = [mins.width, mins.height];\n const maxConstraints = [Math.min(maxes.width, maxWidth), Math.min(maxes.height, Infinity)];\n return (\n \n {child}\n \n );\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 onDragHandler(handlerName:string) {\n return (e:Event, {node, deltaX, deltaY}: DragCallbackData) => {\n if (!this.props[handlerName]) return;\n\n const newPosition: {top: number, left: number} = {top: 0, left: 0};\n\n // Get new XY\n switch (handlerName) {\n case 'onDragStart': {\n // ToDo this wont work on nested parents\n const parentRect = node.offsetParent.getBoundingClientRect();\n const clientRect = node.getBoundingClientRect();\n newPosition.left = clientRect.left - parentRect.left;\n newPosition.top = clientRect.top - parentRect.top;\n this.setState({dragging: newPosition});\n break;\n }\n case 'onDrag':\n if (!this.state.dragging) throw new Error('onDrag called before onDragStart.');\n newPosition.left = this.state.dragging.left + deltaX;\n newPosition.top = this.state.dragging.top + deltaY;\n this.setState({dragging: newPosition});\n break;\n case 'onDragStop':\n if (!this.state.dragging) throw new Error('onDragEnd called before onDragStart.');\n newPosition.left = this.state.dragging.left;\n newPosition.top = this.state.dragging.top;\n this.setState({dragging: null});\n break;\n default:\n throw new Error('onDragHandler called with unrecognized handlerName: ' + handlerName);\n }\n\n const {x, y} = this.calcXY(newPosition.top, newPosition.left);\n\n this.props[handlerName](this.props.i, x, y, {e, node, newPosition});\n };\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(handlerName: string) {\n return (e:Event, {node, size}: {node: HTMLElement, size: Position}) => {\n if (!this.props[handlerName]) return;\n const {cols, x, i, maxW, minW, maxH, minH} = this.props;\n\n // Get new XY\n let {w, h} = this.calcWH(size);\n\n // Cap w at numCols\n w = Math.min(w, cols - x);\n // Ensure w is at least 1\n w = Math.max(w, 1);\n\n // Min/max capping\n w = Math.max(Math.min(w, maxW), minW);\n h = Math.max(Math.min(h, maxH), minH);\n\n this.setState({resizing: handlerName === 'onResizeStop' ? null : size});\n\n this.props[handlerName](i, w, h, {e, node, size});\n };\n }\n\n render(): React.Element {\n const {x, y, w, h, isDraggable, isResizable, useCSSTransforms} = this.props;\n\n const pos = this.calcPosition(x, y, w, h, this.state);\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 className: classNames('react-grid-item', child.props.className, this.props.className, {\n static: this.props.static,\n resizing: Boolean(this.state.resizing),\n 'react-draggable': isDraggable,\n 'react-draggable-dragging': Boolean(this.state.dragging),\n cssTransforms: useCSSTransforms\n }),\n // We can set the width and height on the child, but unfortunately we can't set the position.\n style: {...this.props.style, ...child.props.style, ...this.createStyle(pos)}\n });\n\n // Resizable support. This is usually on but the user can toggle it off.\n if (isResizable) newChild = this.mixinResizable(newChild, pos);\n\n // Draggable support. This is always on, except for with placeholders.\n if (isDraggable) newChild = this.mixinDraggable(newChild);\n\n return newChild;\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/GridItem.jsx","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n return function () {\n return arg;\n };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n return arg;\n};\n\nmodule.exports = emptyFunction;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/fbjs/lib/emptyFunction.js\n// module id = 13\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n validateFormat = function validateFormat(format) {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n validateFormat(format);\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(format.replace(/%s/g, function () {\n return args[argIndex++];\n }));\n error.name = 'Invariant Violation';\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n}\n\nmodule.exports = invariant;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/fbjs/lib/invariant.js\n// module id = 14\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\n\nmodule.exports = function() {\n // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n function shim() {\n invariant(\n false,\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 };\n shim.isRequired = shim;\n function getShim() {\n return shim;\n };\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 instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim\n };\n\n ReactPropTypes.checkPropTypes = emptyFunction;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/factoryWithThrowingShims.js\n// module id = 15\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _Resizable = require('./Resizable');\n\nvar _Resizable2 = _interopRequireDefault(_Resizable);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/*:: import type {Props as ResizableProps} from './Resizable';*/\n/*:: type State = {width: number, height: number};*/\n/*:: type Size = {width: number, height: number};*/\n\n\n// An example use of Resizable.\n/*:: type ResizeData = {element: Element, size: Size};*/\n\nvar ResizableBox = function (_React$Component) {\n _inherits(ResizableBox, _React$Component);\n\n function ResizableBox() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, ResizableBox);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n width: _this.props.width,\n height: _this.props.height\n }, _this.onResize = function (e /*: Event*/, _ref) {\n var element = _ref.element,\n size = _ref.size;\n var width = size.width,\n height = size.height;\n\n\n if (_this.props.onResize) {\n e.persist && e.persist();\n _this.setState(size, function () {\n return _this.props.onResize(e, { element: element, size: size });\n });\n } else {\n _this.setState(size);\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n ResizableBox.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps /*: ResizableProps*/) {\n if (nextProps.width !== this.props.width || nextProps.height !== this.props.height) {\n this.setState({\n width: nextProps.width,\n height: nextProps.height\n });\n }\n };\n\n ResizableBox.prototype.render = function render() /*: React.Element*/ {\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 _props = this.props,\n handleSize = _props.handleSize,\n onResize = _props.onResize,\n onResizeStart = _props.onResizeStart,\n onResizeStop = _props.onResizeStop,\n draggableOpts = _props.draggableOpts,\n minConstraints = _props.minConstraints,\n maxConstraints = _props.maxConstraints,\n lockAspectRatio = _props.lockAspectRatio,\n axis = _props.axis,\n width = _props.width,\n height = _props.height,\n props = _objectWithoutProperties(_props, ['handleSize', 'onResize', 'onResizeStart', 'onResizeStop', 'draggableOpts', 'minConstraints', 'maxConstraints', 'lockAspectRatio', 'axis', 'width', 'height']);\n\n return _react2.default.createElement(\n _Resizable2.default,\n {\n handleSize: handleSize,\n width: this.state.width,\n height: this.state.height,\n onResizeStart: onResizeStart,\n onResize: this.onResize,\n onResizeStop: onResizeStop,\n draggableOpts: draggableOpts,\n minConstraints: minConstraints,\n maxConstraints: maxConstraints,\n lockAspectRatio: lockAspectRatio,\n axis: axis\n },\n _react2.default.createElement('div', _extends({ style: { width: this.state.width + 'px', height: this.state.height + 'px' } }, props))\n );\n };\n\n return ResizableBox;\n}(_react2.default.Component);\n\nResizableBox.propTypes = {\n height: _react.PropTypes.number,\n width: _react.PropTypes.number\n};\nResizableBox.defaultProps = {\n handleSize: [20, 20]\n};\nexports.default = ResizableBox;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-resizable/build/ResizableBox.js\n// module id = 16\n// module chunks = 0","'use strict';\n\nvar _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; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// React.addons.cloneWithProps look-alike that merges style & className.\nmodule.exports = function cloneElement(element /*: React.Element*/, props /*: Object*/) /*: React.Element*/ {\n if (props.style && element.props.style) {\n props.style = _extends({}, element.props.style, props.style);\n }\n if (props.className && element.props.className) {\n props.className = element.props.className + ' ' + props.className;\n }\n return _react2.default.cloneElement(element, props);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-resizable/build/cloneElement.js\n// module id = 17\n// module chunks = 0","'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\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-resizable/index.js\n// module id = 18\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 19\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 20\n// module chunks = 0","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\n\n\n// WEBPACK FOOTER //\n// ./index-dev.js"],"sourceRoot":""}