{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///react-grid-layout.min.js","webpack:///webpack/bootstrap 1f63ca84837635483d70","webpack:///external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}","webpack:///./node_modules/prop-types/index.js","webpack:///./lib/utils.js","webpack:///./node_modules/lodash.isequal/index.js","webpack:///./lib/ReactGridLayout.jsx","webpack:///./node_modules/classnames/index.js","webpack:///./node_modules/react-draggable/dist/react-draggable.js","webpack:///external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}","webpack:///./node_modules/react-resizable/build/Resizable.js","webpack:///./lib/responsiveUtils.js","webpack:///./index-dev.js","webpack:///./node_modules/prop-types/factoryWithThrowingShims.js","webpack:///./node_modules/fbjs/lib/emptyFunction.js","webpack:///./node_modules/fbjs/lib/invariant.js","webpack:///./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack:///(webpack)/buildin/global.js","webpack:///(webpack)/buildin/module.js","webpack:///./lib/GridItem.jsx","webpack:///./node_modules/react-resizable/index.js","webpack:///./node_modules/react-resizable/build/cloneElement.js","webpack:///./node_modules/react-resizable/build/ResizableBox.js","webpack:///./lib/ResponsiveReactGridLayout.jsx","webpack:///./lib/components/WidthProvider.jsx"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE_0__","__WEBPACK_EXTERNAL_MODULE_7__","modules","__webpack_require__","moduleId","installedModules","i","l","call","m","c","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","String","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","value","arrayPush","values","offset","arraySome","baseTimes","iteratee","cacheHas","cache","has","getValue","mapToArray","size","setToArray","set","Hash","entries","clear","entry","hashClear","__data__","nativeCreate","hashDelete","hashGet","data","HASH_UNDEFINED","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","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","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","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","skipCtor","objValue","objCtor","constructor","othCtor","keys","getSymbols","isKeyable","getNative","isOwn","unmasked","e","nativeObjectToString","MAX_SAFE_INTEGER","reIsUint","type","func","maskSrcKey","Ctor","objectProto","funcToString","isArrayLike","isEqual","funcTag","genTag","asyncTag","proxyTag","stubArray","stubFalse","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","arg","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","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","classNames","classes","argType","apply","hasOwn","join","__WEBPACK_EXTERNAL_MODULE_4__","__WEBPACK_EXTERNAL_MODULE_6__","findInArray","callback","isNum","isNaN","int","parseInt","dontSetMe","componentName","makeEmptyFunction","emptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","invariant","condition","format","f","validateFormat","error","args","argIndex","framesToPop","DRAGGABLE_DEBUG","NODE_ENV","_defineProperty","matchesSelector","selector","matchesSelectorFunc","_shims","method","matchesSelectorAndParentsTo","baseNode","parentNode","addEvent","event","handler","attachEvent","addEventListener","removeEvent","detachEvent","removeEventListener","outerHeight","clientHeight","computedStyle","ownerDocument","defaultView","getComputedStyle","borderTopWidth","borderBottomWidth","outerWidth","clientWidth","borderLeftWidth","borderRightWidth","innerHeight","paddingTop","paddingBottom","innerWidth","paddingLeft","paddingRight","offsetXYFromParent","evt","offsetParent","isBody","body","offsetParentRect","getBoundingClientRect","clientX","scrollLeft","clientY","scrollTop","createCSSTransform","_getPrefix","browserPrefixToKey","_getPrefix2","createSVGTransform","getTouch","identifier","targetTouches","t","changedTouches","getTouchIdentifier","addUserSelectStyles","doc","styleEl","getElementById","innerHTML","getElementsByTagName","appendChild","addClassName","removeUserSelectStyles","removeClassName","window","getSelection","removeAllRanges","styleHacks","childStyle","touchAction","classList","match","remove","REACT_ELEMENT_TYPE","for","isValidElement","$$typeof","warning","printWarning","_len","_key","_len2","_key2","getBoundPosition","cloneBounds","findDOMNode","ownerWindow","boundNode","querySelector","HTMLElement","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","right","_domFns","marginRight","marginBottom","snapToGrid","grid","pendingX","pendingY","round","canDragX","axis","canDragY","getControlPosition","touchIdentifier","draggableCore","touchObj","createCoreData","isStart","lastX","deltaX","deltaY","lastY","createDraggableData","coreData","_reactDom2","_reactDom","_slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","iterator","next","done","err","_createClass","defineProperties","descriptor","protoProps","staticProps","_positionFns","_log","_log2","eventsFor","touch","start","move","stop","mouse","dragEventFor","DraggableCore","_temp","_ret","getPrototypeOf","dragging","NaN","handleDragStart","onMouseDown","allowAnyClick","button","thisNode","disabled","Node","coreEvent","onStart","enableUserSelectHack","handleDrag","handleDragStop","preventDefault","_deltaX","_deltaY","_snapToGrid","_snapToGrid2","MouseEvent","document","createEvent","initMouseEvent","onStop","onMouseUp","onTouchStart","onTouchEnd","cloneElement","only","browser","log","Draggable","_DraggableCore","_DraggableCore2","dragged","uiData","newState","_x","_y","slackX","slackY","_getBoundPosition","_getBoundPosition2","_this$props$position","_x2","_y2","defaultPosition","isElementSVG","SVGElement","_classNames","svgTransform","controlled","transformOpts","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","oneOf","oneOfType","shape","ReactPropTypesSecret","checkPropTypes","throwOnDirectAccess","getIteratorFn","maybeIterable","iteratorFn","ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","is","PropTypeError","createChainableTypeChecker","validate","checkType","isRequired","location","propFullName","secret","ANONYMOUS","cacheKey","manualPropTypeCallCache","manualPropTypeWarningCount","chainedCheckType","createPrimitiveTypeChecker","expectedType","propValue","getPropType","getPreciseType","createArrayOfTypeChecker","typeChecker","createInstanceTypeChecker","expectedClass","expectedClassName","getClassName","createEnumTypeChecker","expectedValues","JSON","stringify","createObjectOfTypeChecker","propType","createUnionTypeChecker","arrayOfTypeCheckers","checker","getPostfixForTypeWarning","createShapeTypeChecker","shapeTypes","isNode","every","step","isSymbol","Date","ReactPropTypes","any","element","instanceOf","objectOf","PropTypes","typeSpecs","getStack","typeSpecName","ex","loggedTypeFailures","shim","getShim","getPrefix","prop","documentElement","prefixes","prefix","kebabToTitleCase","browserPrefixToStyle","toLowerCase","str","shouldCapitalize","toUpperCase","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","prependListener","prependOnceListener","listeners","cwd","chdir","dir","umask","_objectWithoutProperties","_reactDraggable","_cloneElement","_cloneElement2","Resizable","resizing","slackW","slackH","lockAspectRatio","aspectRatio","runConstraints","minConstraints","maxConstraints","ratio","oldW","oldH","resizeHandler","handlerName","widthChanged","heightChanged","_runConstraints","persist","draggableOpts","handleSize","getBreakpointFromWidth","breakpoints","sortBreakpoints","matching","breakpointName","getColsFromBreakpoint","breakpoint","findOrGenerateResponsiveLayout","layouts","lastBreakpoint","breakpointsSorted","breakpointsAbove","slice","utils","Responsive","WidthProvider","exact","eval","webpackPolyfill","deprecate","paths","_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","ResizableBox","_Resizable","_Resizable2","_responsiveUtils","_ReactGridLayout","_ReactGridLayout2","ResponsiveReactGridLayout","generateInitialState","_extends2","colNo","onWidthChange","newBreakpoint","newCols","onBreakpointChange","lg","md","sm","xs","xxs","ComposedComponent","_class","_temp2","onWindowResize","_event","offsetWidth","componentWillUnmount","measureBeforeMount"],"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_7__) {\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_7__) {\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/******/ \t\t}\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// 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 = 10);\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/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (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__(11)();\n}\n\n\n/***/ }),\n/* 2 */\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\n// All callbacks are of the signature (layout, oldItem, newItem, placeholder, e).\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 // $FlowIgnore: Appears to think map calls back w/array\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, String(child.key));\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: String(child.key) });\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/* 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__(15), __webpack_require__(16)(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__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _lodash = __webpack_require__(3);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nvar _classnames = __webpack_require__(5);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _utils = __webpack_require__(2);\n\nvar _GridItem = __webpack_require__(17);\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, String(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\n // $FlowIgnore: Appears to think map calls back w/array\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, ?node).\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 \\\"\" + 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\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/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(true)\n\t\tmodule.exports = factory(__webpack_require__(7), __webpack_require__(0));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react-dom\", \"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactDraggable\"] = factory(require(\"react-dom\"), require(\"react\"));\n\telse\n\t\troot[\"ReactDraggable\"] = factory(root[\"ReactDOM\"], root[\"React\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_6__) {\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/******/ \t\t}\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// 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 = 12);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.findInArray = findInArray;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\nexports.int = int;\nexports.dontSetMe = dontSetMe;\n\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array /*: Array | TouchList*/, callback /*: Function*/) /*: any*/ {\n for (var i = 0, length = array.length; i < length; i++) {\n if (callback.apply(callback, [array[i], i, array])) return array[i];\n }\n}\n\nfunction isFunction(func /*: any*/) /*: boolean*/ {\n return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nfunction isNum(num /*: any*/) /*: boolean*/ {\n return typeof num === 'number' && !isNaN(num);\n}\n\nfunction int(a /*: string*/) /*: number*/ {\n return parseInt(a, 10);\n}\n\nfunction dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) {\n if (props[propName]) {\n return new Error('Invalid prop ' + propName + ' passed to ' + componentName + ' - do not set this, set it on the child.');\n }\n}\n\n/***/ }),\n/* 1 */\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/* 2 */\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 (Object({\"DRAGGABLE_DEBUG\":undefined}).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/* 3 */\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 ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_4__;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\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\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.addEvent = addEvent;\nexports.removeEvent = removeEvent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nexports.styleHacks = styleHacks;\nexports.addClassName = addClassName;\nexports.removeClassName = removeClassName;\n\nvar _shims = __webpack_require__(0);\n\nvar _getPrefix = __webpack_require__(18);\n\nvar _getPrefix2 = _interopRequireDefault(_getPrefix);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/*:: import type {ControlPosition, MouseTouchEvent} from './types';*/\n\n\nvar matchesSelectorFunc = '';\nfunction matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/ {\n if (!matchesSelectorFunc) {\n matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n // $FlowIgnore: Doesn't think elements are indexable\n return (0, _shims.isFunction)(el[method]);\n });\n }\n\n // $FlowIgnore: Doesn't think elements are indexable\n return el[matchesSelectorFunc].call(el, selector);\n}\n\n// Works up the tree to the draggable itself attempting to match selector.\nfunction matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/ {\n var node = el;\n do {\n if (matchesSelector(node, selector)) return true;\n if (node === baseNode) return false;\n node = node.parentNode;\n } while (node);\n\n return false;\n}\n\nfunction addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n if (!el) {\n return;\n }\n if (el.attachEvent) {\n el.attachEvent('on' + event, handler);\n } else if (el.addEventListener) {\n el.addEventListener(event, handler, true);\n } else {\n // $FlowIgnore: Doesn't think elements are indexable\n el['on' + event] = handler;\n }\n}\n\nfunction removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n if (!el) {\n return;\n }\n if (el.detachEvent) {\n el.detachEvent('on' + event, handler);\n } else if (el.removeEventListener) {\n el.removeEventListener(event, handler, true);\n } else {\n // $FlowIgnore: Doesn't think elements are indexable\n el['on' + event] = null;\n }\n}\n\nfunction outerHeight(node /*: HTMLElement*/) /*: number*/ {\n // This is deliberately excluding margin for our calculations, since we are using\n // offsetTop which is including margin. See getBoundPosition\n var height = node.clientHeight;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n height += (0, _shims.int)(computedStyle.borderTopWidth);\n height += (0, _shims.int)(computedStyle.borderBottomWidth);\n return height;\n}\n\nfunction outerWidth(node /*: HTMLElement*/) /*: number*/ {\n // This is deliberately excluding margin for our calculations, since we are using\n // offsetLeft which is including margin. See getBoundPosition\n var width = node.clientWidth;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n width += (0, _shims.int)(computedStyle.borderLeftWidth);\n width += (0, _shims.int)(computedStyle.borderRightWidth);\n return width;\n}\nfunction innerHeight(node /*: HTMLElement*/) /*: number*/ {\n var height = node.clientHeight;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n height -= (0, _shims.int)(computedStyle.paddingTop);\n height -= (0, _shims.int)(computedStyle.paddingBottom);\n return height;\n}\n\nfunction innerWidth(node /*: HTMLElement*/) /*: number*/ {\n var width = node.clientWidth;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n width -= (0, _shims.int)(computedStyle.paddingLeft);\n width -= (0, _shims.int)(computedStyle.paddingRight);\n return width;\n}\n\n// Get from offsetParent\nfunction offsetXYFromParent(evt /*: {clientX: number, clientY: number}*/, offsetParent /*: HTMLElement*/) /*: ControlPosition*/ {\n var isBody = offsetParent === offsetParent.ownerDocument.body;\n var offsetParentRect = isBody ? { left: 0, top: 0 } : offsetParent.getBoundingClientRect();\n\n var x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;\n var y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;\n\n return { x: x, y: y };\n}\n\nfunction createCSSTransform(_ref) /*: Object*/ {\n var x = _ref.x,\n y = _ref.y;\n\n // Replace unitless items with px\n return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix2.default), 'translate(' + x + 'px,' + y + 'px)');\n}\n\nfunction createSVGTransform(_ref3) /*: string*/ {\n var x = _ref3.x,\n y = _ref3.y;\n\n return 'translate(' + x + ',' + y + ')';\n}\n\nfunction getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/ {\n return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n return identifier === t.identifier;\n }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n return identifier === t.identifier;\n });\n}\n\nfunction getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/ {\n if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n}\n\n// User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n\n// Note we're passing `document` b/c we could be iframed\nfunction addUserSelectStyles(doc /*: Document*/) {\n var styleEl = doc.getElementById('react-draggable-style-el');\n if (!styleEl) {\n styleEl = doc.createElement('style');\n styleEl.type = 'text/css';\n styleEl.id = 'react-draggable-style-el';\n styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {background: transparent;}\\n';\n styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {background: transparent;}\\n';\n doc.getElementsByTagName('head')[0].appendChild(styleEl);\n }\n if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\n\nfunction removeUserSelectStyles(doc /*: Document*/) {\n if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection');\n window.getSelection().removeAllRanges(); // remove selection caused by scroll\n}\n\nfunction styleHacks() /*: Object*/ {\n var childStyle /*: Object*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n // Workaround IE pointer events; see #51\n // https://github.com/mzabriskie/react-draggable/issues/51#issuecomment-103488278\n return _extends({\n touchAction: 'none'\n }, childStyle);\n}\n\nfunction addClassName(el /*: HTMLElement*/, className /*: string*/) {\n if (el.classList) {\n el.classList.add(className);\n } else {\n if (!el.className.match(new RegExp('(?:^|\\\\s)' + className + '(?!\\\\S)'))) {\n el.className += ' ' + className;\n }\n }\n}\n\nfunction removeClassName(el /*: HTMLElement*/, className /*: string*/) {\n if (el.classList) {\n el.classList.remove(className);\n } else {\n el.className = el.className.replace(new RegExp('(?:^|\\\\s)' + className + '(?!\\\\S)', 'g'), '');\n }\n}\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_6__;\n\n/***/ }),\n/* 7 */\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 (Object({\"DRAGGABLE_DEBUG\":undefined}).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 = __webpack_require__(14)(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__(16)();\n}\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2014-2015, 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\nvar emptyFunction = __webpack_require__(1);\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var printWarning = function printWarning(format) {\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n var argIndex = 0;\n var message = 'Warning: ' + format.replace(/%s/g, function () {\n return args[argIndex++];\n });\n if (typeof console !== 'undefined') {\n console.error(message);\n }\n try {\n // --- Welcome to debugging React ---\n // This error was thrown as a convenience so that you can use this stack\n // to find the callsite that caused this warning to fire.\n throw new Error(message);\n } catch (x) {}\n };\n\n warning = function warning(condition, format) {\n if (format === undefined) {\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n }\n\n if (format.indexOf('Failed Composite propType: ') === 0) {\n return; // Ignore CompositeComponent proptype check.\n }\n\n if (!condition) {\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n args[_key2 - 2] = arguments[_key2];\n }\n\n printWarning.apply(undefined, [format].concat(args));\n }\n };\n}\n\nmodule.exports = warning;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.getBoundPosition = getBoundPosition;\nexports.snapToGrid = snapToGrid;\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.getControlPosition = getControlPosition;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\n\nvar _shims = __webpack_require__(0);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _domFns = __webpack_require__(5);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/*:: import type Draggable from '../Draggable';*/\n/*:: import type {Bounds, ControlPosition, DraggableData, MouseTouchEvent} from './types';*/\n/*:: import type DraggableCore from '../DraggableCore';*/\nfunction getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/ {\n // If no bounds, short-circuit and move on\n if (!draggable.props.bounds) return [x, y];\n\n // Clone new bounds\n var bounds = draggable.props.bounds;\n\n bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n var node = findDOMNode(draggable);\n\n if (typeof bounds === 'string') {\n var ownerDocument = node.ownerDocument;\n\n var ownerWindow = ownerDocument.defaultView;\n var boundNode = void 0;\n if (bounds === 'parent') {\n boundNode = node.parentNode;\n } else {\n boundNode = ownerDocument.querySelector(bounds);\n }\n if (!(boundNode instanceof HTMLElement)) {\n throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n }\n var nodeStyle = ownerWindow.getComputedStyle(node);\n var boundNodeStyle = ownerWindow.getComputedStyle(boundNode);\n // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n bounds = {\n left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),\n top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),\n right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),\n bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)\n };\n }\n\n // Keep x and y below right and bottom limits...\n if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\n // But above left and top limits.\n if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n\n return [x, y];\n}\n\nfunction snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/ {\n var x = Math.round(pendingX / grid[0]) * grid[0];\n var y = Math.round(pendingY / grid[1]) * grid[1];\n return [x, y];\n}\n\nfunction canDragX(draggable /*: Draggable*/) /*: boolean*/ {\n return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nfunction canDragY(draggable /*: Draggable*/) /*: boolean*/ {\n return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n}\n\n// Get {x, y} positions from event.\nfunction getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/ {\n var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n var node = findDOMNode(draggableCore);\n // User can provide an offsetParent if desired.\n var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent);\n}\n\n// Create an data object exposed by 's events\nfunction createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/ {\n var state = draggable.state;\n var isStart = !(0, _shims.isNum)(state.lastX);\n var node = findDOMNode(draggable);\n\n if (isStart) {\n // If this is our first move, use the x and y as last coords.\n return {\n node: node,\n deltaX: 0, deltaY: 0,\n lastX: x, lastY: y,\n x: x, y: y\n };\n } else {\n // Otherwise calculate proper values.\n return {\n node: node,\n deltaX: x - state.lastX, deltaY: y - state.lastY,\n lastX: state.lastX, lastY: state.lastY,\n x: x, y: y\n };\n }\n}\n\n// Create an data exposed by 's events\nfunction createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/ {\n return {\n node: coreData.node,\n x: draggable.state.x + coreData.deltaX,\n y: draggable.state.y + coreData.deltaY,\n deltaX: coreData.deltaX,\n deltaY: coreData.deltaY,\n lastX: draggable.state.x,\n lastY: draggable.state.y\n };\n}\n\n// A lot faster than stringify/parse\nfunction cloneBounds(bounds /*: Bounds*/) /*: Bounds*/ {\n return {\n left: bounds.left,\n top: bounds.top,\n right: bounds.right,\n bottom: bounds.bottom\n };\n}\n\nfunction findDOMNode(draggable /*: Draggable | DraggableCore*/) /*: HTMLElement*/ {\n var node = _reactDom2.default.findDOMNode(draggable);\n if (!node) {\n throw new Error(': Unmounted during event!');\n }\n // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n return node;\n}\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _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\nvar _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\nvar _react = __webpack_require__(6);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(7);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _domFns = __webpack_require__(5);\n\nvar _positionFns = __webpack_require__(9);\n\nvar _shims = __webpack_require__(0);\n\nvar _log = __webpack_require__(11);\n\nvar _log2 = _interopRequireDefault(_log);\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/*:: import type {EventHandler, MouseTouchEvent} from './utils/types';*/\n\n\n// Simple abstraction for dragging events names.\n/*:: import type {Element as ReactElement} from 'react';*/\nvar eventsFor = {\n touch: {\n start: 'touchstart',\n move: 'touchmove',\n stop: 'touchend'\n },\n mouse: {\n start: 'mousedown',\n move: 'mousemove',\n stop: 'mouseup'\n }\n};\n\n// Default to mouse events.\nvar dragEventFor = eventsFor.mouse;\n\n/*:: type DraggableCoreState = {\n dragging: boolean,\n lastX: number,\n lastY: number,\n touchIdentifier: ?number\n};*/\n/*:: export type DraggableBounds = {\n left: number,\n right: number,\n top: number,\n bottom: number,\n};*/\n/*:: export type DraggableData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number,\n};*/\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void;*/\n/*:: export type ControlPosition = {x: number, y: number};*/\n\n\n//\n// Define .\n//\n// is for advanced usage of . It maintains minimal internal state so it can\n// work well with libraries that require more control over the element.\n//\n\n/*:: export type DraggableCoreProps = {\n allowAnyClick: boolean,\n cancel: string,\n children: ReactElement,\n disabled: boolean,\n enableUserSelectHack: boolean,\n offsetParent: HTMLElement,\n grid: [number, number],\n handle: string,\n onStart: DraggableEventHandler,\n onDrag: DraggableEventHandler,\n onStop: DraggableEventHandler,\n onMouseDown: (e: MouseEvent) => void,\n};*/\n\nvar DraggableCore = function (_React$Component) {\n _inherits(DraggableCore, _React$Component);\n\n function DraggableCore() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, DraggableCore);\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, (_ref = DraggableCore.__proto__ || Object.getPrototypeOf(DraggableCore)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n dragging: false,\n // Used while dragging to determine deltas.\n lastX: NaN, lastY: NaN,\n touchIdentifier: null\n }, _this.handleDragStart = function (e) {\n // Make it possible to attach event handlers on top of this one.\n _this.props.onMouseDown(e);\n\n // Only accept left-clicks.\n if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\n // Get nodes. Be sure to grab relative document (could be iframed)\n var thisNode = _reactDom2.default.findDOMNode(_this);\n if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n throw new Error(' not mounted on DragStart!');\n }\n var ownerDocument = thisNode.ownerDocument;\n\n // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\n if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {\n return;\n }\n\n // Set touch identifier in component state if this is a touch event. This allows us to\n // distinguish between individual touches on multitouch screens by identifying which\n // touchpoint was set to this element.\n var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n _this.setState({ touchIdentifier: touchIdentifier });\n\n // Get the current drag point from the event. This is used as the offset.\n var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _this);\n if (position == null) return; // not possible but satisfies flow\n var x = position.x,\n y = position.y;\n\n // Create an event object with all the data parents need to make a decision here.\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n (0, _log2.default)('DraggableCore: handleDragStart: %j', coreEvent);\n\n // Call event handler. If it returns explicit false, cancel.\n (0, _log2.default)('calling', _this.props.onStart);\n var shouldUpdate = _this.props.onStart(e, coreEvent);\n if (shouldUpdate === false) return;\n\n // Add a style to the body to disable user-select. This prevents text from\n // being selected all over the page.\n if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument);\n\n // Initiate dragging. Set the current x and y as offsets\n // so we know how much we've moved during the drag. This allows us\n // to drag elements around even if they have been moved, without issue.\n _this.setState({\n dragging: true,\n\n lastX: x,\n lastY: y\n });\n\n // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n // this element. We use different events depending on whether or not we have detected that this\n // is a touch-capable device.\n (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n }, _this.handleDrag = function (e) {\n\n // Prevent scrolling on mobile devices, like ipad/iphone.\n if (e.type === 'touchmove') e.preventDefault();\n\n // Get the current drag point from the event. This is used as the offset.\n var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n if (position == null) return;\n var x = position.x,\n y = position.y;\n\n // Snap to grid if prop has been provided\n\n if (Array.isArray(_this.props.grid)) {\n var _deltaX = x - _this.state.lastX,\n _deltaY = y - _this.state.lastY;\n\n var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, _deltaX, _deltaY);\n\n var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\n _deltaX = _snapToGrid2[0];\n _deltaY = _snapToGrid2[1];\n\n if (!_deltaX && !_deltaY) return; // skip useless drag\n x = _this.state.lastX + _deltaX, y = _this.state.lastY + _deltaY;\n }\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n (0, _log2.default)('DraggableCore: handleDrag: %j', coreEvent);\n\n // Call event handler. If it returns explicit false, trigger end.\n var shouldUpdate = _this.props.onDrag(e, coreEvent);\n if (shouldUpdate === false) {\n try {\n // $FlowIgnore\n _this.handleDragStop(new MouseEvent('mouseup'));\n } catch (err) {\n // Old browsers\n var event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);\n // I see why this insanity was deprecated\n // $FlowIgnore\n event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n _this.handleDragStop(event);\n }\n return;\n }\n\n _this.setState({\n lastX: x,\n lastY: y\n });\n }, _this.handleDragStop = function (e) {\n if (!_this.state.dragging) return;\n\n var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n if (position == null) return;\n var x = position.x,\n y = position.y;\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n var thisNode = _reactDom2.default.findDOMNode(_this);\n if (thisNode) {\n // Remove user-select hack\n if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n }\n\n (0, _log2.default)('DraggableCore: handleDragStop: %j', coreEvent);\n\n // Reset the el.\n _this.setState({\n dragging: false,\n lastX: NaN,\n lastY: NaN\n });\n\n // Call event handler\n _this.props.onStop(e, coreEvent);\n\n if (thisNode) {\n // Remove event handlers\n (0, _log2.default)('DraggableCore: Removing handlers');\n (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);\n (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);\n }\n }, _this.onMouseDown = function (e) {\n dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n return _this.handleDragStart(e);\n }, _this.onMouseUp = function (e) {\n dragEventFor = eventsFor.mouse;\n\n return _this.handleDragStop(e);\n }, _this.onTouchStart = function (e) {\n // We're on a touch device now, so change the event handlers\n dragEventFor = eventsFor.touch;\n\n return _this.handleDragStart(e);\n }, _this.onTouchEnd = function (e) {\n // We're on a touch device now, so change the event handlers\n dragEventFor = eventsFor.touch;\n\n return _this.handleDragStop(e);\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(DraggableCore, [{\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n var thisNode = _reactDom2.default.findDOMNode(this);\n if (thisNode) {\n var ownerDocument = thisNode.ownerDocument;\n\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);\n }\n }\n\n // Same as onMouseDown (start drag), but now consider this a touch device.\n\n }, {\n key: 'render',\n value: function render() {\n // Reuse the child provided\n // This makes it flexible to use whatever element is wanted (div, ul, etc)\n return _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n style: (0, _domFns.styleHacks)(this.props.children.props.style),\n\n // Note: mouseMove handler is attached to document so it will still function\n // when the user drags quickly and leaves the bounds of the element.\n onMouseDown: this.onMouseDown,\n onTouchStart: this.onTouchStart,\n onMouseUp: this.onMouseUp,\n onTouchEnd: this.onTouchEnd\n });\n }\n }]);\n\n return DraggableCore;\n}(_react2.default.Component);\n\nDraggableCore.displayName = 'DraggableCore';\nDraggableCore.propTypes = {\n /**\n * `allowAnyClick` allows dragging using any mouse button.\n * By default, we only accept the left button.\n *\n * Defaults to `false`.\n */\n allowAnyClick: _propTypes2.default.bool,\n\n /**\n * `disabled`, if true, stops the from dragging. All handlers,\n * with the exception of `onMouseDown`, will not fire.\n */\n disabled: _propTypes2.default.bool,\n\n /**\n * By default, we add 'user-select:none' attributes to the document body\n * to prevent ugly text selection during drag. If this is causing problems\n * for your app, set this to `false`.\n */\n enableUserSelectHack: _propTypes2.default.bool,\n\n /**\n * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n * instead of using the parent node.\n */\n offsetParent: function offsetParent(props, propName) {\n if (process.browser && props[propName] && props[propName].nodeType !== 1) {\n throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n }\n },\n\n /**\n * `grid` specifies the x and y that dragging should snap to.\n */\n grid: _propTypes2.default.arrayOf(_propTypes2.default.number),\n\n /**\n * `handle` specifies a selector to be used as the handle that initiates drag.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
\n *
Click me to drag
\n *
This is some other content
\n *
\n * \n * );\n * }\n * });\n * ```\n */\n handle: _propTypes2.default.string,\n\n /**\n * `cancel` specifies a selector to be used to prevent drag initialization.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return(\n * \n *
\n *
You can't drag from here
\n *
Dragging here works fine
\n *
\n * \n * );\n * }\n * });\n * ```\n */\n cancel: _propTypes2.default.string,\n\n /**\n * Called when dragging starts.\n * If this function returns the boolean false, dragging will be canceled.\n */\n onStart: _propTypes2.default.func,\n\n /**\n * Called while dragging.\n * If this function returns the boolean false, dragging will be canceled.\n */\n onDrag: _propTypes2.default.func,\n\n /**\n * Called when dragging stops.\n * If this function returns the boolean false, the drag will remain active.\n */\n onStop: _propTypes2.default.func,\n\n /**\n * A workaround option which can be passed if onMouseDown needs to be accessed,\n * since it'll always be blocked (as there is internal use of onMouseDown)\n */\n onMouseDown: _propTypes2.default.func,\n\n /**\n * These properties should be defined on the child, not here.\n */\n className: _shims.dontSetMe,\n style: _shims.dontSetMe,\n transform: _shims.dontSetMe\n};\nDraggableCore.defaultProps = {\n allowAnyClick: false, // by default only accept left click\n cancel: null,\n disabled: false,\n enableUserSelectHack: true,\n offsetParent: null,\n handle: null,\n grid: null,\n transform: null,\n onStart: function onStart() {},\n onDrag: function onDrag() {},\n onStop: function onStop() {},\n onMouseDown: function onMouseDown() {}\n};\nexports.default = DraggableCore;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(19)))\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = log;\n\n/*eslint no-console:0*/\nfunction log() {\n var _console;\n\n if (undefined) (_console = console).log.apply(_console, arguments);\n}\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Draggable = __webpack_require__(13).default;\n\n// Previous versions of this lib exported as the root export. As to not break\n// them, or TypeScript, we export *both* as the root and as 'default'.\n// See https://github.com/mzabriskie/react-draggable/pull/254\n// and https://github.com/mzabriskie/react-draggable/issues/266\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = __webpack_require__(10).default;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\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 _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\nvar _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\nvar _react = __webpack_require__(6);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(7);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _classnames = __webpack_require__(17);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _domFns = __webpack_require__(5);\n\nvar _positionFns = __webpack_require__(9);\n\nvar _shims = __webpack_require__(0);\n\nvar _DraggableCore = __webpack_require__(10);\n\nvar _DraggableCore2 = _interopRequireDefault(_DraggableCore);\n\nvar _log = __webpack_require__(11);\n\nvar _log2 = _interopRequireDefault(_log);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _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 {ControlPosition, DraggableBounds, DraggableCoreProps} from './DraggableCore';*/\n/*:: import type {DraggableEventHandler} from './utils/types';*/\n/*:: import type {Element as ReactElement} from 'react';*/\n/*:: type DraggableState = {\n dragging: boolean,\n dragged: boolean,\n x: number, y: number,\n slackX: number, slackY: number,\n isElementSVG: boolean\n};*/\n\n\n//\n// Define \n//\n\n/*:: export type DraggableProps = {\n ...$Exact,\n axis: 'both' | 'x' | 'y' | 'none',\n bounds: DraggableBounds | string | false,\n defaultClassName: string,\n defaultClassNameDragging: string,\n defaultClassNameDragged: string,\n defaultPosition: ControlPosition,\n position: ControlPosition,\n};*/\n\nvar Draggable = function (_React$Component) {\n _inherits(Draggable, _React$Component);\n\n function Draggable(props /*: DraggableProps*/) {\n _classCallCheck(this, Draggable);\n\n var _this = _possibleConstructorReturn(this, (Draggable.__proto__ || Object.getPrototypeOf(Draggable)).call(this, props));\n\n _this.onDragStart = function (e, coreData) {\n (0, _log2.default)('Draggable: onDragStart: %j', coreData);\n\n // Short-circuit if user's callback killed it.\n var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_this, coreData));\n // Kills start event on core as well, so move handlers are never bound.\n if (shouldStart === false) return false;\n\n _this.setState({ dragging: true, dragged: true });\n };\n\n _this.onDrag = function (e, coreData) {\n if (!_this.state.dragging) return false;\n (0, _log2.default)('Draggable: onDrag: %j', coreData);\n\n var uiData = (0, _positionFns.createDraggableData)(_this, coreData);\n\n var newState /*: $Shape*/ = {\n x: uiData.x,\n y: uiData.y\n };\n\n // Keep within bounds.\n if (_this.props.bounds) {\n // Save original x and y.\n var _x = newState.x,\n _y = newState.y;\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 newState.x += _this.state.slackX;\n newState.y += _this.state.slackY;\n\n // Get bound position. This will ceil/floor the x and y within the boundaries.\n // $FlowBug\n\n // Recalculate slack by noting how much was shaved by the boundPosition handler.\n var _getBoundPosition = (0, _positionFns.getBoundPosition)(_this, newState.x, newState.y);\n\n var _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2);\n\n newState.x = _getBoundPosition2[0];\n newState.y = _getBoundPosition2[1];\n newState.slackX = _this.state.slackX + (_x - newState.x);\n newState.slackY = _this.state.slackY + (_y - newState.y);\n\n // Update the event we fire to reflect what really happened after bounds took effect.\n uiData.x = newState.x;\n uiData.y = newState.y;\n uiData.deltaX = newState.x - _this.state.x;\n uiData.deltaY = newState.y - _this.state.y;\n }\n\n // Short-circuit if user's callback killed it.\n var shouldUpdate = _this.props.onDrag(e, uiData);\n if (shouldUpdate === false) return false;\n\n _this.setState(newState);\n };\n\n _this.onDragStop = function (e, coreData) {\n if (!_this.state.dragging) return false;\n\n // Short-circuit if user's callback killed it.\n var shouldStop = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_this, coreData));\n if (shouldStop === false) return false;\n\n (0, _log2.default)('Draggable: onDragStop: %j', coreData);\n\n var newState /*: $Shape*/ = {\n dragging: false,\n slackX: 0,\n slackY: 0\n };\n\n // If this is a controlled component, the result of this operation will be to\n // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n var controlled = Boolean(_this.props.position);\n if (controlled) {\n var _this$props$position = _this.props.position,\n _x2 = _this$props$position.x,\n _y2 = _this$props$position.y;\n\n newState.x = _x2;\n newState.y = _y2;\n }\n\n _this.setState(newState);\n };\n\n _this.state = {\n // Whether or not we are currently dragging.\n dragging: false,\n\n // Whether or not we have been dragged before.\n dragged: false,\n\n // Current transform x and y.\n x: props.position ? props.position.x : props.defaultPosition.x,\n y: props.position ? props.position.y : props.defaultPosition.y,\n\n // Used for compensating for out-of-bounds drags\n slackX: 0, slackY: 0,\n\n // Can only determine if SVG after mounting\n isElementSVG: false\n };\n return _this;\n }\n\n _createClass(Draggable, [{\n key: 'componentWillMount',\n value: function componentWillMount() {\n if (this.props.position && !(this.props.onDrag || this.props.onStop)) {\n // eslint-disable-next-line\n 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 }\n }\n }, {\n key: 'componentDidMount',\n value: function componentDidMount() {\n // Check to see if the element passed is an instanceof SVGElement\n if (typeof window.SVGElement !== 'undefined' && _reactDom2.default.findDOMNode(this) instanceof window.SVGElement) {\n this.setState({ isElementSVG: true });\n }\n }\n }, {\n key: 'componentWillReceiveProps',\n value: function componentWillReceiveProps(nextProps /*: Object*/) {\n // Set x/y if position has changed\n if (nextProps.position && (!this.props.position || nextProps.position.x !== this.props.position.x || nextProps.position.y !== this.props.position.y)) {\n this.setState({ x: nextProps.position.x, y: nextProps.position.y });\n }\n }\n }, {\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n this.setState({ dragging: false }); // prevents invariant if unmounted while dragging\n }\n }, {\n key: 'render',\n value: function render() /*: ReactElement*/ {\n var _classNames;\n\n var style = {},\n svgTransform = null;\n\n // If this is controlled, we don't want to move it - unless it's dragging.\n var controlled = Boolean(this.props.position);\n var draggable = !controlled || this.state.dragging;\n\n var position = this.props.position || this.props.defaultPosition;\n var transformOpts = {\n // Set left if horizontal drag is enabled\n x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : position.x,\n\n // Set top if vertical drag is enabled\n y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : position.y\n };\n\n // If this element was SVG, we use the `transform` attribute.\n if (this.state.isElementSVG) {\n svgTransform = (0, _domFns.createSVGTransform)(transformOpts);\n } else {\n // Add a CSS transform to move the element around. This allows us to move the element around\n // without worrying about whether or not it is relatively or absolutely positioned.\n // If the item you are dragging already has a transform set, wrap it in a so \n // has a clean slate.\n style = (0, _domFns.createCSSTransform)(transformOpts);\n }\n\n var _props = this.props,\n defaultClassName = _props.defaultClassName,\n defaultClassNameDragging = _props.defaultClassNameDragging,\n defaultClassNameDragged = _props.defaultClassNameDragged;\n\n // Mark with class while dragging\n\n 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\n // Reuse the child provided\n // This makes it flexible to use whatever element is wanted (div, ul, etc)\n return _react2.default.createElement(\n _DraggableCore2.default,\n _extends({}, this.props, { onStart: this.onDragStart, onDrag: this.onDrag, onStop: this.onDragStop }),\n _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n className: className,\n style: _extends({}, this.props.children.props.style, style),\n transform: svgTransform\n })\n );\n }\n }]);\n\n return Draggable;\n}(_react2.default.Component);\n\nDraggable.displayName = 'Draggable';\nDraggable.propTypes = _extends({}, _DraggableCore2.default.propTypes, {\n\n /**\n * `axis` determines which axis the draggable can move.\n *\n * Note that all callbacks will still return data as normal. This only\n * controls flushing to the DOM.\n *\n * 'both' allows movement horizontally and vertically.\n * 'x' limits movement to horizontal axis.\n * 'y' limits movement to vertical axis.\n * 'none' limits all movement.\n *\n * Defaults to 'both'.\n */\n axis: _propTypes2.default.oneOf(['both', 'x', 'y', 'none']),\n\n /**\n * `bounds` determines the range of movement available to the element.\n * Available values are:\n *\n * 'parent' restricts movement within the Draggable's parent node.\n *\n * Alternatively, pass an object with the following properties, all of which are optional:\n *\n * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n *\n * All values are in px.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
Content
\n * \n * );\n * }\n * });\n * ```\n */\n bounds: _propTypes2.default.oneOfType([_propTypes2.default.shape({\n left: _propTypes2.default.number,\n right: _propTypes2.default.number,\n top: _propTypes2.default.number,\n bottom: _propTypes2.default.number\n }), _propTypes2.default.string, _propTypes2.default.oneOf([false])]),\n\n defaultClassName: _propTypes2.default.string,\n defaultClassNameDragging: _propTypes2.default.string,\n defaultClassNameDragged: _propTypes2.default.string,\n\n /**\n * `defaultPosition` specifies the x and y that the dragged item should start at\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
I start with transformX: 25px and transformY: 25px;
\n * \n * );\n * }\n * });\n * ```\n */\n defaultPosition: _propTypes2.default.shape({\n x: _propTypes2.default.number,\n y: _propTypes2.default.number\n }),\n\n /**\n * `position`, if present, defines the current position of the element.\n *\n * This is similar to how form elements in React work - if no `position` is supplied, the component\n * is uncontrolled.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
I start with transformX: 25px and transformY: 25px;
\n * \n * );\n * }\n * });\n * ```\n */\n position: _propTypes2.default.shape({\n x: _propTypes2.default.number,\n y: _propTypes2.default.number\n }),\n\n /**\n * These properties should be defined on the child, not here.\n */\n className: _shims.dontSetMe,\n style: _shims.dontSetMe,\n transform: _shims.dontSetMe\n});\nDraggable.defaultProps = _extends({}, _DraggableCore2.default.defaultProps, {\n axis: 'both',\n bounds: false,\n defaultClassName: 'react-draggable',\n defaultClassNameDragging: 'react-draggable-dragging',\n defaultClassNameDragged: 'react-draggable-dragged',\n defaultPosition: { x: 0, y: 0 },\n position: null\n});\nexports.default = Draggable;\n\n/***/ }),\n/* 14 */\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__(1);\nvar invariant = __webpack_require__(2);\nvar warning = __webpack_require__(8);\n\nvar ReactPropTypesSecret = __webpack_require__(3);\nvar checkPropTypes = __webpack_require__(15);\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n /* global Symbol */\n var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n /**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\n function getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n }\n\n /**\n * Collection of methods that allow declaration and validation of props that are\n * supplied to React components. Example usage:\n *\n * var Props = require('ReactPropTypes');\n * var MyArticle = React.createClass({\n * propTypes: {\n * // An optional string prop named \"description\".\n * description: Props.string,\n *\n * // A required enum prop named \"category\".\n * category: Props.oneOf(['News','Photos']).isRequired,\n *\n * // A prop named \"dialog\" that requires an instance of Dialog.\n * dialog: Props.instanceOf(Dialog).isRequired\n * },\n * render: function() { ... }\n * });\n *\n * A more formal specification of how these methods are used:\n *\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n * decl := ReactPropTypes.{type}(.isRequired)?\n *\n * Each and every declaration produces a function with the same signature. This\n * allows the creation of custom validation functions. For example:\n *\n * var MyLink = React.createClass({\n * propTypes: {\n * // An optional string or URI prop named \"href\".\n * href: function(props, propName, componentName) {\n * var propValue = props[propName];\n * if (propValue != null && typeof propValue !== 'string' &&\n * !(propValue instanceof URI)) {\n * return new Error(\n * 'Expected a string or an URI for ' + propName + ' in ' +\n * componentName\n * );\n * }\n * }\n * },\n * render: function() {...}\n * });\n *\n * @internal\n */\n\n var ANONYMOUS = '<>';\n\n // Important!\n // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n var ReactPropTypes = {\n array: createPrimitiveTypeChecker('array'),\n bool: createPrimitiveTypeChecker('boolean'),\n func: createPrimitiveTypeChecker('function'),\n number: createPrimitiveTypeChecker('number'),\n object: createPrimitiveTypeChecker('object'),\n string: createPrimitiveTypeChecker('string'),\n symbol: createPrimitiveTypeChecker('symbol'),\n\n any: createAnyTypeChecker(),\n arrayOf: createArrayOfTypeChecker,\n element: createElementTypeChecker(),\n instanceOf: createInstanceTypeChecker,\n node: createNodeChecker(),\n objectOf: createObjectOfTypeChecker,\n oneOf: createEnumTypeChecker,\n oneOfType: createUnionTypeChecker,\n shape: createShapeTypeChecker\n };\n\n /**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\n /*eslint-disable no-self-compare*/\n function is(x, y) {\n // SameValue algorithm\n if (x === y) {\n // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n return x !== 0 || 1 / x === 1 / y;\n } else {\n // Step 6.a: NaN == NaN\n return x !== x && y !== y;\n }\n }\n /*eslint-enable no-self-compare*/\n\n /**\n * We use an Error-like object for backward compatibility as people may call\n * PropTypes directly and inspect their output. However, we don't use real\n * Errors anymore. We don't inspect their stack anyway, and creating them\n * is prohibitively expensive if they are created too often, such as what\n * happens in oneOfType() for any type before the one that matched.\n */\n function PropTypeError(message) {\n this.message = message;\n this.stack = '';\n }\n // Make `instanceof Error` still work for returned errors.\n PropTypeError.prototype = Error.prototype;\n\n function createChainableTypeChecker(validate) {\n if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var manualPropTypeCallCache = {};\n var manualPropTypeWarningCount = 0;\n }\n function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n componentName = componentName || ANONYMOUS;\n propFullName = propFullName || propName;\n\n if (secret !== ReactPropTypesSecret) {\n if (throwOnDirectAccess) {\n // New behavior only for users of `prop-types` package\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 } else if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' && typeof console !== 'undefined') {\n // Old behavior for people using React.PropTypes\n var cacheKey = componentName + ':' + propName;\n if (\n !manualPropTypeCallCache[cacheKey] &&\n // Avoid spamming the console because they are often not actionable except for lib authors\n manualPropTypeWarningCount < 3\n ) {\n warning(\n false,\n 'You are manually calling a React.PropTypes validation ' +\n 'function for the `%s` prop on `%s`. This is deprecated ' +\n 'and will throw in the standalone `prop-types` package. ' +\n 'You may be seeing this warning due to a third-party PropTypes ' +\n 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',\n propFullName,\n componentName\n );\n manualPropTypeCallCache[cacheKey] = true;\n manualPropTypeWarningCount++;\n }\n }\n }\n if (props[propName] == null) {\n if (isRequired) {\n if (props[propName] === null) {\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n }\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n }\n return null;\n } else {\n return validate(props, propName, componentName, location, propFullName);\n }\n }\n\n var chainedCheckType = checkType.bind(null, false);\n chainedCheckType.isRequired = checkType.bind(null, true);\n\n return chainedCheckType;\n }\n\n function createPrimitiveTypeChecker(expectedType) {\n function validate(props, propName, componentName, location, propFullName, secret) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== expectedType) {\n // `propValue` being instance of, say, date/regexp, pass the 'object'\n // check, but we can offer a more precise error message here rather than\n // 'of type `object`'.\n var preciseType = getPreciseType(propValue);\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createAnyTypeChecker() {\n return createChainableTypeChecker(emptyFunction.thatReturnsNull);\n }\n\n function createArrayOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n }\n var propValue = props[propName];\n if (!Array.isArray(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n }\n for (var i = 0; i < propValue.length; i++) {\n var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createElementTypeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n if (!isValidElement(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createInstanceTypeChecker(expectedClass) {\n function validate(props, propName, componentName, location, propFullName) {\n if (!(props[propName] instanceof expectedClass)) {\n var expectedClassName = expectedClass.name || ANONYMOUS;\n var actualClassName = getClassName(props[propName]);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createEnumTypeChecker(expectedValues) {\n if (!Array.isArray(expectedValues)) {\n Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n for (var i = 0; i < expectedValues.length; i++) {\n if (is(propValue, expectedValues[i])) {\n return null;\n }\n }\n\n var valuesString = JSON.stringify(expectedValues);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createObjectOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n }\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n }\n for (var key in propValue) {\n if (propValue.hasOwnProperty(key)) {\n var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createUnionTypeChecker(arrayOfTypeCheckers) {\n if (!Array.isArray(arrayOfTypeCheckers)) {\n Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (typeof checker !== 'function') {\n warning(\n false,\n 'Invalid argument supplid to oneOfType. Expected an array of check functions, but ' +\n 'received %s at index %s.',\n getPostfixForTypeWarning(checker),\n i\n );\n return emptyFunction.thatReturnsNull;\n }\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n return null;\n }\n }\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createNodeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n if (!isNode(props[propName])) {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createShapeTypeChecker(shapeTypes) {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n }\n for (var key in shapeTypes) {\n var checker = shapeTypes[key];\n if (!checker) {\n continue;\n }\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function isNode(propValue) {\n switch (typeof propValue) {\n case 'number':\n case 'string':\n case 'undefined':\n return true;\n case 'boolean':\n return !propValue;\n case 'object':\n if (Array.isArray(propValue)) {\n return propValue.every(isNode);\n }\n if (propValue === null || isValidElement(propValue)) {\n return true;\n }\n\n var iteratorFn = getIteratorFn(propValue);\n if (iteratorFn) {\n var iterator = iteratorFn.call(propValue);\n var step;\n if (iteratorFn !== propValue.entries) {\n while (!(step = iterator.next()).done) {\n if (!isNode(step.value)) {\n return false;\n }\n }\n } else {\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n if (!isNode(entry[1])) {\n return false;\n }\n }\n }\n }\n } else {\n return false;\n }\n\n return true;\n default:\n return false;\n }\n }\n\n function isSymbol(propType, propValue) {\n // Native Symbol.\n if (propType === 'symbol') {\n return true;\n }\n\n // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n if (propValue['@@toStringTag'] === 'Symbol') {\n return true;\n }\n\n // Fallback for non-spec compliant Symbols which are polyfilled.\n if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n return true;\n }\n\n return false;\n }\n\n // Equivalent of `typeof` but with special handling for array and regexp.\n function getPropType(propValue) {\n var propType = typeof propValue;\n if (Array.isArray(propValue)) {\n return 'array';\n }\n if (propValue instanceof RegExp) {\n // Old webkits (at least until Android 4.0) return 'function' rather than\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n // passes PropTypes.object.\n return 'object';\n }\n if (isSymbol(propType, propValue)) {\n return 'symbol';\n }\n return propType;\n }\n\n // This handles more types than `getPropType`. Only used for error messages.\n // See `createPrimitiveTypeChecker`.\n function getPreciseType(propValue) {\n if (typeof propValue === 'undefined' || propValue === null) {\n return '' + propValue;\n }\n var propType = getPropType(propValue);\n if (propType === 'object') {\n if (propValue instanceof Date) {\n return 'date';\n } else if (propValue instanceof RegExp) {\n return 'regexp';\n }\n }\n return propType;\n }\n\n // Returns a string that is postfixed to a warning about an invalid type.\n // For example, \"undefined\" or \"of type array\"\n function getPostfixForTypeWarning(value) {\n var type = getPreciseType(value);\n switch (type) {\n case 'array':\n case 'object':\n return 'an ' + type;\n case 'boolean':\n case 'date':\n case 'regexp':\n return 'a ' + type;\n default:\n return type;\n }\n }\n\n // Returns class name of the object, if any.\n function getClassName(propValue) {\n if (!propValue.constructor || !propValue.constructor.name) {\n return ANONYMOUS;\n }\n return propValue.constructor.name;\n }\n\n ReactPropTypes.checkPropTypes = checkPropTypes;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\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\nif (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var invariant = __webpack_require__(2);\n var warning = __webpack_require__(8);\n var ReactPropTypesSecret = __webpack_require__(3);\n var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n for (var typeSpecName in typeSpecs) {\n if (typeSpecs.hasOwnProperty(typeSpecName)) {\n var error;\n // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', location, typeSpecName);\n error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n } catch (ex) {\n error = ex;\n }\n warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var stack = getStack ? getStack() : '';\n\n warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n }\n }\n }\n }\n}\n\nmodule.exports = checkPropTypes;\n\n\n/***/ }),\n/* 16 */\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__(1);\nvar invariant = __webpack_require__(2);\nvar ReactPropTypesSecret = __webpack_require__(3);\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n 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 // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n 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/* 17 */\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/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.getPrefix = getPrefix;\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\nfunction getPrefix() /*: string*/ {\n var prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n\n // Checking specifically for 'window.document' is for pseudo-browser server-side\n // environments that define 'window' as the global context.\n // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n\n var style = window.document.documentElement.style;\n\n if (prop in style) return '';\n\n for (var i = 0; i < prefixes.length; i++) {\n if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n }\n\n return '';\n}\n\nfunction browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n return prefix ? '' + prefix + kebabToTitleCase(prop) : prop;\n}\n\nfunction browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n return prefix ? '-' + prefix.toLowerCase() + '-' + prop : prop;\n}\n\nfunction kebabToTitleCase(str /*: string*/) /*: string*/ {\n var out = '';\n var shouldCapitalize = true;\n for (var i = 0; i < str.length; i++) {\n if (shouldCapitalize) {\n out += str[i].toUpperCase();\n shouldCapitalize = false;\n } else if (str[i] === '-') {\n shouldCapitalize = true;\n } else {\n out += str[i];\n }\n }\n return out;\n}\n\n// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\nexports.default = getPrefix();\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // 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 return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // 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 return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // 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 return cachedClearTimeout.call(null, marker);\n } catch (e){\n // 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 // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=react-draggable.js.map\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_7__;\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 _propTypes = __webpack_require__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDraggable = __webpack_require__(6);\n\nvar _cloneElement = __webpack_require__(19);\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\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) {\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, height, aspectRatio) {\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, height) {\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) {\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\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() {\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: _propTypes2.default.element.isRequired,\n\n // Initial w/h\n width: _propTypes2.default.number.isRequired,\n height: _propTypes2.default.number.isRequired,\n\n //\n // Optional props\n //\n\n // If you change this, be sure to update your css\n handleSize: _propTypes2.default.array,\n\n // If true, will only allow width/height to move in lockstep\n lockAspectRatio: _propTypes2.default.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: _propTypes2.default.oneOf(['both', 'x', 'y', 'none']),\n\n // Min/max size\n minConstraints: _propTypes2.default.arrayOf(_propTypes2.default.number),\n maxConstraints: _propTypes2.default.arrayOf(_propTypes2.default.number),\n\n // Callbacks\n onResizeStop: _propTypes2.default.func,\n onResizeStart: _propTypes2.default.func,\n onResize: _propTypes2.default.func,\n\n // These will be passed wholesale to react-draggable's DraggableCore\n draggableOpts: _propTypes2.default.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, __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__(2);\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/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(4).default;\nmodule.exports.utils = __webpack_require__(2);\nmodule.exports.Responsive = __webpack_require__(21).default;\nmodule.exports.Responsive.utils = __webpack_require__(9);\nmodule.exports.WidthProvider = __webpack_require__(22).default;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\n\nvar emptyFunction = __webpack_require__(12);\nvar invariant = __webpack_require__(13);\nvar ReactPropTypesSecret = __webpack_require__(14);\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n 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 // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim,\n exact: getShim\n };\n\n ReactPropTypes.checkPropTypes = emptyFunction;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\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/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\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/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n/***/ }),\n/* 15 */\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/* 16 */\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/* 17 */\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__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDraggable = __webpack_require__(6);\n\nvar _reactResizable = __webpack_require__(18);\n\nvar _utils = __webpack_require__(2);\n\nvar _classnames = __webpack_require__(5);\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 var handler = _this2.props[handlerName];\n if (!handler) 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 + node.offsetParent.scrollLeft;\n newPosition.top = clientRect.top - parentRect.top + node.offsetParent.scrollTop;\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 handler.call(_this2, _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 var handler = _this3.props[handlerName];\n if (!handler) 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 handler.call(_this3, 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 handle: '',\n minH: 1,\n minW: 1,\n maxH: Infinity,\n maxW: Infinity\n};\nexports.default = GridItem;\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__(20).default;\n\n\n/***/ }),\n/* 19 */\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, props) {\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/* 20 */\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__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\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// An example use of Resizable.\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, data) {\n var size = data.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 && _this.props.onResize(e, data);\n });\n } else {\n _this.setState(size);\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n ResizableBox.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\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() {\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: _propTypes2.default.number,\n width: _propTypes2.default.number\n};\nResizableBox.defaultProps = {\n handleSize: [20, 20]\n};\nexports.default = ResizableBox;\n\n/***/ }),\n/* 21 */\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__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _lodash = __webpack_require__(3);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nvar _utils = __webpack_require__(2);\n\nvar _responsiveUtils = __webpack_require__(9);\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/* 22 */\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__(1);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(7);\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/******/ ]);\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 \t\t}\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// 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 = 10);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 1f63ca84837635483d70","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","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n var 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// ./node_modules/prop-types/index.js\n// module id = 1\n// module chunks = 0","// @flow\nimport isEqual from 'lodash.isequal';\nimport React from 'react';\nimport type {ChildrenArray as ReactChildrenArray, Element as ReactElement} from 'react';\nexport type LayoutItem = {\n w: number, h: number, x: number, y: number, i: string,\n minW?: number, minH?: number, maxW?: number, maxH?: number,\n moved?: boolean, static?: boolean,\n isDraggable?: ?boolean, isResizable?: ?boolean\n};\nexport type Layout = Array;\nexport type Position = {left: number, top: number, width: number, height: number};\nexport type ReactDraggableCallbackData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number\n};\n\nexport type PartialPosition = {left: number, top: number};\nexport type Size = {width: number, height: number};\nexport type GridDragEvent = {e: Event, node: HTMLElement, newPosition: PartialPosition};\nexport type GridResizeEvent = {e: Event, node: HTMLElement, size: Size};\n\ntype REl = ReactElement;\nexport type ReactChildren = ReactChildrenArray;\n\n// All callbacks are of the signature (layout, oldItem, newItem, placeholder, e).\nexport type EventCallback =\n (Layout, oldItem: ?LayoutItem, newItem: ?LayoutItem, placeholder: ?LayoutItem, Event, ?HTMLElement) => void;\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 // $FlowIgnore: Appears to think map calls back w/array\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: ReactElement, i: number) => {\n // Don't overwrite if it already exists.\n const exists = getLayoutItem(initialLayout, String(child.key));\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: String(child.key)});\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 * 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// ./node_modules/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';\nimport type {ChildrenArray as ReactChildrenArray, Element as ReactElement} from 'react';\nconst noop = function() {};\n\n// Types\nimport type {EventCallback, GridResizeEvent, GridDragEvent, 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\nexport type Props = {\n className: string,\n style: Object,\n width: number,\n autoSize: boolean,\n cols: number,\n draggableCancel: string,\n draggableHandle: string,\n verticalCompact: boolean,\n layout: Layout,\n margin: [number, number],\n containerPadding: [number, number],\n rowHeight: number,\n maxRows: number,\n isDraggable: boolean,\n isResizable: boolean,\n useCSSTransforms: boolean,\n\n // Callbacks\n onLayoutChange: (Layout) => void,\n onDrag: EventCallback,\n onDragStart: EventCallback,\n onDragStop: EventCallback,\n onResize: EventCallback,\n onResizeStart: EventCallback,\n onResizeStop: EventCallback,\n children: ReactChildrenArray>,\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, ?node).\n // All callbacks below have the same signature. 'start' and 'stop' callbacks omit the 'placeholder'.\n onDragStart: PropTypes.func,\n // Calls on each drag movement.\n onDrag: PropTypes.func,\n // Calls when drag is complete.\n onDragStop: PropTypes.func,\n //Calls when resize starts.\n onResizeStart: PropTypes.func,\n // Calls when resize movement happens.\n onResize: PropTypes.func,\n // Calls when resize is complete.\n onResizeStop: PropTypes.func,\n\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 \\\"\" + 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: Props, 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: Props) {\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}: GridDragEvent) {\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}: GridDragEvent) {\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}: GridDragEvent) {\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}: GridResizeEvent) {\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}: GridResizeEvent) {\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}: GridResizeEvent) {\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(): ?ReactElement {\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: ReactElement): ?ReactElement {\n if (!child.key) return;\n const l = getLayoutItem(this.state.layout, String(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 // $FlowIgnore: Appears to think map calls back w/array\n React.Children.map(this.props.children, (child) => this.processGridItem(child))\n }\n {this.placeholder()}\n
\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/ReactGridLayout.jsx","/*!\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// ./node_modules/classnames/index.js\n// module id = 5\n// module chunks = 0","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react-dom\"), require(\"react\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react-dom\", \"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactDraggable\"] = factory(require(\"react-dom\"), require(\"react\"));\n\telse\n\t\troot[\"ReactDraggable\"] = factory(root[\"ReactDOM\"], root[\"React\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_6__) {\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/******/ \t\t}\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// 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 = 12);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.findInArray = findInArray;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\nexports.int = int;\nexports.dontSetMe = dontSetMe;\n\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array /*: Array | TouchList*/, callback /*: Function*/) /*: any*/ {\n for (var i = 0, length = array.length; i < length; i++) {\n if (callback.apply(callback, [array[i], i, array])) return array[i];\n }\n}\n\nfunction isFunction(func /*: any*/) /*: boolean*/ {\n return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nfunction isNum(num /*: any*/) /*: boolean*/ {\n return typeof num === 'number' && !isNaN(num);\n}\n\nfunction int(a /*: string*/) /*: number*/ {\n return parseInt(a, 10);\n}\n\nfunction dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) {\n if (props[propName]) {\n return new Error('Invalid prop ' + propName + ' passed to ' + componentName + ' - do not set this, set it on the child.');\n }\n}\n\n/***/ }),\n/* 1 */\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/* 2 */\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 (Object({\"DRAGGABLE_DEBUG\":undefined}).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/* 3 */\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 ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_4__;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\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\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.addEvent = addEvent;\nexports.removeEvent = removeEvent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nexports.styleHacks = styleHacks;\nexports.addClassName = addClassName;\nexports.removeClassName = removeClassName;\n\nvar _shims = __webpack_require__(0);\n\nvar _getPrefix = __webpack_require__(18);\n\nvar _getPrefix2 = _interopRequireDefault(_getPrefix);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/*:: import type {ControlPosition, MouseTouchEvent} from './types';*/\n\n\nvar matchesSelectorFunc = '';\nfunction matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/ {\n if (!matchesSelectorFunc) {\n matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n // $FlowIgnore: Doesn't think elements are indexable\n return (0, _shims.isFunction)(el[method]);\n });\n }\n\n // $FlowIgnore: Doesn't think elements are indexable\n return el[matchesSelectorFunc].call(el, selector);\n}\n\n// Works up the tree to the draggable itself attempting to match selector.\nfunction matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/ {\n var node = el;\n do {\n if (matchesSelector(node, selector)) return true;\n if (node === baseNode) return false;\n node = node.parentNode;\n } while (node);\n\n return false;\n}\n\nfunction addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n if (!el) {\n return;\n }\n if (el.attachEvent) {\n el.attachEvent('on' + event, handler);\n } else if (el.addEventListener) {\n el.addEventListener(event, handler, true);\n } else {\n // $FlowIgnore: Doesn't think elements are indexable\n el['on' + event] = handler;\n }\n}\n\nfunction removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/) /*: void*/ {\n if (!el) {\n return;\n }\n if (el.detachEvent) {\n el.detachEvent('on' + event, handler);\n } else if (el.removeEventListener) {\n el.removeEventListener(event, handler, true);\n } else {\n // $FlowIgnore: Doesn't think elements are indexable\n el['on' + event] = null;\n }\n}\n\nfunction outerHeight(node /*: HTMLElement*/) /*: number*/ {\n // This is deliberately excluding margin for our calculations, since we are using\n // offsetTop which is including margin. See getBoundPosition\n var height = node.clientHeight;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n height += (0, _shims.int)(computedStyle.borderTopWidth);\n height += (0, _shims.int)(computedStyle.borderBottomWidth);\n return height;\n}\n\nfunction outerWidth(node /*: HTMLElement*/) /*: number*/ {\n // This is deliberately excluding margin for our calculations, since we are using\n // offsetLeft which is including margin. See getBoundPosition\n var width = node.clientWidth;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n width += (0, _shims.int)(computedStyle.borderLeftWidth);\n width += (0, _shims.int)(computedStyle.borderRightWidth);\n return width;\n}\nfunction innerHeight(node /*: HTMLElement*/) /*: number*/ {\n var height = node.clientHeight;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n height -= (0, _shims.int)(computedStyle.paddingTop);\n height -= (0, _shims.int)(computedStyle.paddingBottom);\n return height;\n}\n\nfunction innerWidth(node /*: HTMLElement*/) /*: number*/ {\n var width = node.clientWidth;\n var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n width -= (0, _shims.int)(computedStyle.paddingLeft);\n width -= (0, _shims.int)(computedStyle.paddingRight);\n return width;\n}\n\n// Get from offsetParent\nfunction offsetXYFromParent(evt /*: {clientX: number, clientY: number}*/, offsetParent /*: HTMLElement*/) /*: ControlPosition*/ {\n var isBody = offsetParent === offsetParent.ownerDocument.body;\n var offsetParentRect = isBody ? { left: 0, top: 0 } : offsetParent.getBoundingClientRect();\n\n var x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;\n var y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;\n\n return { x: x, y: y };\n}\n\nfunction createCSSTransform(_ref) /*: Object*/ {\n var x = _ref.x,\n y = _ref.y;\n\n // Replace unitless items with px\n return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix2.default), 'translate(' + x + 'px,' + y + 'px)');\n}\n\nfunction createSVGTransform(_ref3) /*: string*/ {\n var x = _ref3.x,\n y = _ref3.y;\n\n return 'translate(' + x + ',' + y + ')';\n}\n\nfunction getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/ {\n return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n return identifier === t.identifier;\n }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n return identifier === t.identifier;\n });\n}\n\nfunction getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/ {\n if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n}\n\n// User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n\n// Note we're passing `document` b/c we could be iframed\nfunction addUserSelectStyles(doc /*: Document*/) {\n var styleEl = doc.getElementById('react-draggable-style-el');\n if (!styleEl) {\n styleEl = doc.createElement('style');\n styleEl.type = 'text/css';\n styleEl.id = 'react-draggable-style-el';\n styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {background: transparent;}\\n';\n styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {background: transparent;}\\n';\n doc.getElementsByTagName('head')[0].appendChild(styleEl);\n }\n if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\n\nfunction removeUserSelectStyles(doc /*: Document*/) {\n if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection');\n window.getSelection().removeAllRanges(); // remove selection caused by scroll\n}\n\nfunction styleHacks() /*: Object*/ {\n var childStyle /*: Object*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n // Workaround IE pointer events; see #51\n // https://github.com/mzabriskie/react-draggable/issues/51#issuecomment-103488278\n return _extends({\n touchAction: 'none'\n }, childStyle);\n}\n\nfunction addClassName(el /*: HTMLElement*/, className /*: string*/) {\n if (el.classList) {\n el.classList.add(className);\n } else {\n if (!el.className.match(new RegExp('(?:^|\\\\s)' + className + '(?!\\\\S)'))) {\n el.className += ' ' + className;\n }\n }\n}\n\nfunction removeClassName(el /*: HTMLElement*/, className /*: string*/) {\n if (el.classList) {\n el.classList.remove(className);\n } else {\n el.className = el.className.replace(new RegExp('(?:^|\\\\s)' + className + '(?!\\\\S)', 'g'), '');\n }\n}\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_6__;\n\n/***/ }),\n/* 7 */\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 (Object({\"DRAGGABLE_DEBUG\":undefined}).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 = __webpack_require__(14)(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__(16)();\n}\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2014-2015, 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\nvar emptyFunction = __webpack_require__(1);\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var printWarning = function printWarning(format) {\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n var argIndex = 0;\n var message = 'Warning: ' + format.replace(/%s/g, function () {\n return args[argIndex++];\n });\n if (typeof console !== 'undefined') {\n console.error(message);\n }\n try {\n // --- Welcome to debugging React ---\n // This error was thrown as a convenience so that you can use this stack\n // to find the callsite that caused this warning to fire.\n throw new Error(message);\n } catch (x) {}\n };\n\n warning = function warning(condition, format) {\n if (format === undefined) {\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n }\n\n if (format.indexOf('Failed Composite propType: ') === 0) {\n return; // Ignore CompositeComponent proptype check.\n }\n\n if (!condition) {\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n args[_key2 - 2] = arguments[_key2];\n }\n\n printWarning.apply(undefined, [format].concat(args));\n }\n };\n}\n\nmodule.exports = warning;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.getBoundPosition = getBoundPosition;\nexports.snapToGrid = snapToGrid;\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.getControlPosition = getControlPosition;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\n\nvar _shims = __webpack_require__(0);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _domFns = __webpack_require__(5);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/*:: import type Draggable from '../Draggable';*/\n/*:: import type {Bounds, ControlPosition, DraggableData, MouseTouchEvent} from './types';*/\n/*:: import type DraggableCore from '../DraggableCore';*/\nfunction getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/ {\n // If no bounds, short-circuit and move on\n if (!draggable.props.bounds) return [x, y];\n\n // Clone new bounds\n var bounds = draggable.props.bounds;\n\n bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n var node = findDOMNode(draggable);\n\n if (typeof bounds === 'string') {\n var ownerDocument = node.ownerDocument;\n\n var ownerWindow = ownerDocument.defaultView;\n var boundNode = void 0;\n if (bounds === 'parent') {\n boundNode = node.parentNode;\n } else {\n boundNode = ownerDocument.querySelector(bounds);\n }\n if (!(boundNode instanceof HTMLElement)) {\n throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n }\n var nodeStyle = ownerWindow.getComputedStyle(node);\n var boundNodeStyle = ownerWindow.getComputedStyle(boundNode);\n // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n bounds = {\n left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),\n top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),\n right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),\n bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)\n };\n }\n\n // Keep x and y below right and bottom limits...\n if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\n // But above left and top limits.\n if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n\n return [x, y];\n}\n\nfunction snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/ {\n var x = Math.round(pendingX / grid[0]) * grid[0];\n var y = Math.round(pendingY / grid[1]) * grid[1];\n return [x, y];\n}\n\nfunction canDragX(draggable /*: Draggable*/) /*: boolean*/ {\n return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nfunction canDragY(draggable /*: Draggable*/) /*: boolean*/ {\n return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n}\n\n// Get {x, y} positions from event.\nfunction getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/ {\n var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n var node = findDOMNode(draggableCore);\n // User can provide an offsetParent if desired.\n var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent);\n}\n\n// Create an data object exposed by 's events\nfunction createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/ {\n var state = draggable.state;\n var isStart = !(0, _shims.isNum)(state.lastX);\n var node = findDOMNode(draggable);\n\n if (isStart) {\n // If this is our first move, use the x and y as last coords.\n return {\n node: node,\n deltaX: 0, deltaY: 0,\n lastX: x, lastY: y,\n x: x, y: y\n };\n } else {\n // Otherwise calculate proper values.\n return {\n node: node,\n deltaX: x - state.lastX, deltaY: y - state.lastY,\n lastX: state.lastX, lastY: state.lastY,\n x: x, y: y\n };\n }\n}\n\n// Create an data exposed by 's events\nfunction createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/ {\n return {\n node: coreData.node,\n x: draggable.state.x + coreData.deltaX,\n y: draggable.state.y + coreData.deltaY,\n deltaX: coreData.deltaX,\n deltaY: coreData.deltaY,\n lastX: draggable.state.x,\n lastY: draggable.state.y\n };\n}\n\n// A lot faster than stringify/parse\nfunction cloneBounds(bounds /*: Bounds*/) /*: Bounds*/ {\n return {\n left: bounds.left,\n top: bounds.top,\n right: bounds.right,\n bottom: bounds.bottom\n };\n}\n\nfunction findDOMNode(draggable /*: Draggable | DraggableCore*/) /*: HTMLElement*/ {\n var node = _reactDom2.default.findDOMNode(draggable);\n if (!node) {\n throw new Error(': Unmounted during event!');\n }\n // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n return node;\n}\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _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\nvar _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\nvar _react = __webpack_require__(6);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(7);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _domFns = __webpack_require__(5);\n\nvar _positionFns = __webpack_require__(9);\n\nvar _shims = __webpack_require__(0);\n\nvar _log = __webpack_require__(11);\n\nvar _log2 = _interopRequireDefault(_log);\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/*:: import type {EventHandler, MouseTouchEvent} from './utils/types';*/\n\n\n// Simple abstraction for dragging events names.\n/*:: import type {Element as ReactElement} from 'react';*/\nvar eventsFor = {\n touch: {\n start: 'touchstart',\n move: 'touchmove',\n stop: 'touchend'\n },\n mouse: {\n start: 'mousedown',\n move: 'mousemove',\n stop: 'mouseup'\n }\n};\n\n// Default to mouse events.\nvar dragEventFor = eventsFor.mouse;\n\n/*:: type DraggableCoreState = {\n dragging: boolean,\n lastX: number,\n lastY: number,\n touchIdentifier: ?number\n};*/\n/*:: export type DraggableBounds = {\n left: number,\n right: number,\n top: number,\n bottom: number,\n};*/\n/*:: export type DraggableData = {\n node: HTMLElement,\n x: number, y: number,\n deltaX: number, deltaY: number,\n lastX: number, lastY: number,\n};*/\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void;*/\n/*:: export type ControlPosition = {x: number, y: number};*/\n\n\n//\n// Define .\n//\n// is for advanced usage of . It maintains minimal internal state so it can\n// work well with libraries that require more control over the element.\n//\n\n/*:: export type DraggableCoreProps = {\n allowAnyClick: boolean,\n cancel: string,\n children: ReactElement,\n disabled: boolean,\n enableUserSelectHack: boolean,\n offsetParent: HTMLElement,\n grid: [number, number],\n handle: string,\n onStart: DraggableEventHandler,\n onDrag: DraggableEventHandler,\n onStop: DraggableEventHandler,\n onMouseDown: (e: MouseEvent) => void,\n};*/\n\nvar DraggableCore = function (_React$Component) {\n _inherits(DraggableCore, _React$Component);\n\n function DraggableCore() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, DraggableCore);\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, (_ref = DraggableCore.__proto__ || Object.getPrototypeOf(DraggableCore)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n dragging: false,\n // Used while dragging to determine deltas.\n lastX: NaN, lastY: NaN,\n touchIdentifier: null\n }, _this.handleDragStart = function (e) {\n // Make it possible to attach event handlers on top of this one.\n _this.props.onMouseDown(e);\n\n // Only accept left-clicks.\n if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\n // Get nodes. Be sure to grab relative document (could be iframed)\n var thisNode = _reactDom2.default.findDOMNode(_this);\n if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n throw new Error(' not mounted on DragStart!');\n }\n var ownerDocument = thisNode.ownerDocument;\n\n // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\n if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {\n return;\n }\n\n // Set touch identifier in component state if this is a touch event. This allows us to\n // distinguish between individual touches on multitouch screens by identifying which\n // touchpoint was set to this element.\n var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n _this.setState({ touchIdentifier: touchIdentifier });\n\n // Get the current drag point from the event. This is used as the offset.\n var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _this);\n if (position == null) return; // not possible but satisfies flow\n var x = position.x,\n y = position.y;\n\n // Create an event object with all the data parents need to make a decision here.\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n (0, _log2.default)('DraggableCore: handleDragStart: %j', coreEvent);\n\n // Call event handler. If it returns explicit false, cancel.\n (0, _log2.default)('calling', _this.props.onStart);\n var shouldUpdate = _this.props.onStart(e, coreEvent);\n if (shouldUpdate === false) return;\n\n // Add a style to the body to disable user-select. This prevents text from\n // being selected all over the page.\n if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument);\n\n // Initiate dragging. Set the current x and y as offsets\n // so we know how much we've moved during the drag. This allows us\n // to drag elements around even if they have been moved, without issue.\n _this.setState({\n dragging: true,\n\n lastX: x,\n lastY: y\n });\n\n // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n // this element. We use different events depending on whether or not we have detected that this\n // is a touch-capable device.\n (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n }, _this.handleDrag = function (e) {\n\n // Prevent scrolling on mobile devices, like ipad/iphone.\n if (e.type === 'touchmove') e.preventDefault();\n\n // Get the current drag point from the event. This is used as the offset.\n var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n if (position == null) return;\n var x = position.x,\n y = position.y;\n\n // Snap to grid if prop has been provided\n\n if (Array.isArray(_this.props.grid)) {\n var _deltaX = x - _this.state.lastX,\n _deltaY = y - _this.state.lastY;\n\n var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, _deltaX, _deltaY);\n\n var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\n _deltaX = _snapToGrid2[0];\n _deltaY = _snapToGrid2[1];\n\n if (!_deltaX && !_deltaY) return; // skip useless drag\n x = _this.state.lastX + _deltaX, y = _this.state.lastY + _deltaY;\n }\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n (0, _log2.default)('DraggableCore: handleDrag: %j', coreEvent);\n\n // Call event handler. If it returns explicit false, trigger end.\n var shouldUpdate = _this.props.onDrag(e, coreEvent);\n if (shouldUpdate === false) {\n try {\n // $FlowIgnore\n _this.handleDragStop(new MouseEvent('mouseup'));\n } catch (err) {\n // Old browsers\n var event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);\n // I see why this insanity was deprecated\n // $FlowIgnore\n event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n _this.handleDragStop(event);\n }\n return;\n }\n\n _this.setState({\n lastX: x,\n lastY: y\n });\n }, _this.handleDragStop = function (e) {\n if (!_this.state.dragging) return;\n\n var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _this);\n if (position == null) return;\n var x = position.x,\n y = position.y;\n\n var coreEvent = (0, _positionFns.createCoreData)(_this, x, y);\n\n var thisNode = _reactDom2.default.findDOMNode(_this);\n if (thisNode) {\n // Remove user-select hack\n if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n }\n\n (0, _log2.default)('DraggableCore: handleDragStop: %j', coreEvent);\n\n // Reset the el.\n _this.setState({\n dragging: false,\n lastX: NaN,\n lastY: NaN\n });\n\n // Call event handler\n _this.props.onStop(e, coreEvent);\n\n if (thisNode) {\n // Remove event handlers\n (0, _log2.default)('DraggableCore: Removing handlers');\n (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);\n (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);\n }\n }, _this.onMouseDown = function (e) {\n dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n return _this.handleDragStart(e);\n }, _this.onMouseUp = function (e) {\n dragEventFor = eventsFor.mouse;\n\n return _this.handleDragStop(e);\n }, _this.onTouchStart = function (e) {\n // We're on a touch device now, so change the event handlers\n dragEventFor = eventsFor.touch;\n\n return _this.handleDragStart(e);\n }, _this.onTouchEnd = function (e) {\n // We're on a touch device now, so change the event handlers\n dragEventFor = eventsFor.touch;\n\n return _this.handleDragStop(e);\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(DraggableCore, [{\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n var thisNode = _reactDom2.default.findDOMNode(this);\n if (thisNode) {\n var ownerDocument = thisNode.ownerDocument;\n\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);\n }\n }\n\n // Same as onMouseDown (start drag), but now consider this a touch device.\n\n }, {\n key: 'render',\n value: function render() {\n // Reuse the child provided\n // This makes it flexible to use whatever element is wanted (div, ul, etc)\n return _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n style: (0, _domFns.styleHacks)(this.props.children.props.style),\n\n // Note: mouseMove handler is attached to document so it will still function\n // when the user drags quickly and leaves the bounds of the element.\n onMouseDown: this.onMouseDown,\n onTouchStart: this.onTouchStart,\n onMouseUp: this.onMouseUp,\n onTouchEnd: this.onTouchEnd\n });\n }\n }]);\n\n return DraggableCore;\n}(_react2.default.Component);\n\nDraggableCore.displayName = 'DraggableCore';\nDraggableCore.propTypes = {\n /**\n * `allowAnyClick` allows dragging using any mouse button.\n * By default, we only accept the left button.\n *\n * Defaults to `false`.\n */\n allowAnyClick: _propTypes2.default.bool,\n\n /**\n * `disabled`, if true, stops the from dragging. All handlers,\n * with the exception of `onMouseDown`, will not fire.\n */\n disabled: _propTypes2.default.bool,\n\n /**\n * By default, we add 'user-select:none' attributes to the document body\n * to prevent ugly text selection during drag. If this is causing problems\n * for your app, set this to `false`.\n */\n enableUserSelectHack: _propTypes2.default.bool,\n\n /**\n * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n * instead of using the parent node.\n */\n offsetParent: function offsetParent(props, propName) {\n if (process.browser && props[propName] && props[propName].nodeType !== 1) {\n throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n }\n },\n\n /**\n * `grid` specifies the x and y that dragging should snap to.\n */\n grid: _propTypes2.default.arrayOf(_propTypes2.default.number),\n\n /**\n * `handle` specifies a selector to be used as the handle that initiates drag.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
\n *
Click me to drag
\n *
This is some other content
\n *
\n * \n * );\n * }\n * });\n * ```\n */\n handle: _propTypes2.default.string,\n\n /**\n * `cancel` specifies a selector to be used to prevent drag initialization.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return(\n * \n *
\n *
You can't drag from here
\n *
Dragging here works fine
\n *
\n * \n * );\n * }\n * });\n * ```\n */\n cancel: _propTypes2.default.string,\n\n /**\n * Called when dragging starts.\n * If this function returns the boolean false, dragging will be canceled.\n */\n onStart: _propTypes2.default.func,\n\n /**\n * Called while dragging.\n * If this function returns the boolean false, dragging will be canceled.\n */\n onDrag: _propTypes2.default.func,\n\n /**\n * Called when dragging stops.\n * If this function returns the boolean false, the drag will remain active.\n */\n onStop: _propTypes2.default.func,\n\n /**\n * A workaround option which can be passed if onMouseDown needs to be accessed,\n * since it'll always be blocked (as there is internal use of onMouseDown)\n */\n onMouseDown: _propTypes2.default.func,\n\n /**\n * These properties should be defined on the child, not here.\n */\n className: _shims.dontSetMe,\n style: _shims.dontSetMe,\n transform: _shims.dontSetMe\n};\nDraggableCore.defaultProps = {\n allowAnyClick: false, // by default only accept left click\n cancel: null,\n disabled: false,\n enableUserSelectHack: true,\n offsetParent: null,\n handle: null,\n grid: null,\n transform: null,\n onStart: function onStart() {},\n onDrag: function onDrag() {},\n onStop: function onStop() {},\n onMouseDown: function onMouseDown() {}\n};\nexports.default = DraggableCore;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(19)))\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = log;\n\n/*eslint no-console:0*/\nfunction log() {\n var _console;\n\n if (undefined) (_console = console).log.apply(_console, arguments);\n}\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Draggable = __webpack_require__(13).default;\n\n// Previous versions of this lib exported as the root export. As to not break\n// them, or TypeScript, we export *both* as the root and as 'default'.\n// See https://github.com/mzabriskie/react-draggable/pull/254\n// and https://github.com/mzabriskie/react-draggable/issues/266\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = __webpack_require__(10).default;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\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 _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\nvar _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\nvar _react = __webpack_require__(6);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = __webpack_require__(7);\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = __webpack_require__(4);\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _classnames = __webpack_require__(17);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _domFns = __webpack_require__(5);\n\nvar _positionFns = __webpack_require__(9);\n\nvar _shims = __webpack_require__(0);\n\nvar _DraggableCore = __webpack_require__(10);\n\nvar _DraggableCore2 = _interopRequireDefault(_DraggableCore);\n\nvar _log = __webpack_require__(11);\n\nvar _log2 = _interopRequireDefault(_log);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _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 {ControlPosition, DraggableBounds, DraggableCoreProps} from './DraggableCore';*/\n/*:: import type {DraggableEventHandler} from './utils/types';*/\n/*:: import type {Element as ReactElement} from 'react';*/\n/*:: type DraggableState = {\n dragging: boolean,\n dragged: boolean,\n x: number, y: number,\n slackX: number, slackY: number,\n isElementSVG: boolean\n};*/\n\n\n//\n// Define \n//\n\n/*:: export type DraggableProps = {\n ...$Exact,\n axis: 'both' | 'x' | 'y' | 'none',\n bounds: DraggableBounds | string | false,\n defaultClassName: string,\n defaultClassNameDragging: string,\n defaultClassNameDragged: string,\n defaultPosition: ControlPosition,\n position: ControlPosition,\n};*/\n\nvar Draggable = function (_React$Component) {\n _inherits(Draggable, _React$Component);\n\n function Draggable(props /*: DraggableProps*/) {\n _classCallCheck(this, Draggable);\n\n var _this = _possibleConstructorReturn(this, (Draggable.__proto__ || Object.getPrototypeOf(Draggable)).call(this, props));\n\n _this.onDragStart = function (e, coreData) {\n (0, _log2.default)('Draggable: onDragStart: %j', coreData);\n\n // Short-circuit if user's callback killed it.\n var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_this, coreData));\n // Kills start event on core as well, so move handlers are never bound.\n if (shouldStart === false) return false;\n\n _this.setState({ dragging: true, dragged: true });\n };\n\n _this.onDrag = function (e, coreData) {\n if (!_this.state.dragging) return false;\n (0, _log2.default)('Draggable: onDrag: %j', coreData);\n\n var uiData = (0, _positionFns.createDraggableData)(_this, coreData);\n\n var newState /*: $Shape*/ = {\n x: uiData.x,\n y: uiData.y\n };\n\n // Keep within bounds.\n if (_this.props.bounds) {\n // Save original x and y.\n var _x = newState.x,\n _y = newState.y;\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 newState.x += _this.state.slackX;\n newState.y += _this.state.slackY;\n\n // Get bound position. This will ceil/floor the x and y within the boundaries.\n // $FlowBug\n\n // Recalculate slack by noting how much was shaved by the boundPosition handler.\n var _getBoundPosition = (0, _positionFns.getBoundPosition)(_this, newState.x, newState.y);\n\n var _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2);\n\n newState.x = _getBoundPosition2[0];\n newState.y = _getBoundPosition2[1];\n newState.slackX = _this.state.slackX + (_x - newState.x);\n newState.slackY = _this.state.slackY + (_y - newState.y);\n\n // Update the event we fire to reflect what really happened after bounds took effect.\n uiData.x = newState.x;\n uiData.y = newState.y;\n uiData.deltaX = newState.x - _this.state.x;\n uiData.deltaY = newState.y - _this.state.y;\n }\n\n // Short-circuit if user's callback killed it.\n var shouldUpdate = _this.props.onDrag(e, uiData);\n if (shouldUpdate === false) return false;\n\n _this.setState(newState);\n };\n\n _this.onDragStop = function (e, coreData) {\n if (!_this.state.dragging) return false;\n\n // Short-circuit if user's callback killed it.\n var shouldStop = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_this, coreData));\n if (shouldStop === false) return false;\n\n (0, _log2.default)('Draggable: onDragStop: %j', coreData);\n\n var newState /*: $Shape*/ = {\n dragging: false,\n slackX: 0,\n slackY: 0\n };\n\n // If this is a controlled component, the result of this operation will be to\n // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n var controlled = Boolean(_this.props.position);\n if (controlled) {\n var _this$props$position = _this.props.position,\n _x2 = _this$props$position.x,\n _y2 = _this$props$position.y;\n\n newState.x = _x2;\n newState.y = _y2;\n }\n\n _this.setState(newState);\n };\n\n _this.state = {\n // Whether or not we are currently dragging.\n dragging: false,\n\n // Whether or not we have been dragged before.\n dragged: false,\n\n // Current transform x and y.\n x: props.position ? props.position.x : props.defaultPosition.x,\n y: props.position ? props.position.y : props.defaultPosition.y,\n\n // Used for compensating for out-of-bounds drags\n slackX: 0, slackY: 0,\n\n // Can only determine if SVG after mounting\n isElementSVG: false\n };\n return _this;\n }\n\n _createClass(Draggable, [{\n key: 'componentWillMount',\n value: function componentWillMount() {\n if (this.props.position && !(this.props.onDrag || this.props.onStop)) {\n // eslint-disable-next-line\n 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 }\n }\n }, {\n key: 'componentDidMount',\n value: function componentDidMount() {\n // Check to see if the element passed is an instanceof SVGElement\n if (typeof window.SVGElement !== 'undefined' && _reactDom2.default.findDOMNode(this) instanceof window.SVGElement) {\n this.setState({ isElementSVG: true });\n }\n }\n }, {\n key: 'componentWillReceiveProps',\n value: function componentWillReceiveProps(nextProps /*: Object*/) {\n // Set x/y if position has changed\n if (nextProps.position && (!this.props.position || nextProps.position.x !== this.props.position.x || nextProps.position.y !== this.props.position.y)) {\n this.setState({ x: nextProps.position.x, y: nextProps.position.y });\n }\n }\n }, {\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n this.setState({ dragging: false }); // prevents invariant if unmounted while dragging\n }\n }, {\n key: 'render',\n value: function render() /*: ReactElement*/ {\n var _classNames;\n\n var style = {},\n svgTransform = null;\n\n // If this is controlled, we don't want to move it - unless it's dragging.\n var controlled = Boolean(this.props.position);\n var draggable = !controlled || this.state.dragging;\n\n var position = this.props.position || this.props.defaultPosition;\n var transformOpts = {\n // Set left if horizontal drag is enabled\n x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : position.x,\n\n // Set top if vertical drag is enabled\n y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : position.y\n };\n\n // If this element was SVG, we use the `transform` attribute.\n if (this.state.isElementSVG) {\n svgTransform = (0, _domFns.createSVGTransform)(transformOpts);\n } else {\n // Add a CSS transform to move the element around. This allows us to move the element around\n // without worrying about whether or not it is relatively or absolutely positioned.\n // If the item you are dragging already has a transform set, wrap it in a so \n // has a clean slate.\n style = (0, _domFns.createCSSTransform)(transformOpts);\n }\n\n var _props = this.props,\n defaultClassName = _props.defaultClassName,\n defaultClassNameDragging = _props.defaultClassNameDragging,\n defaultClassNameDragged = _props.defaultClassNameDragged;\n\n // Mark with class while dragging\n\n 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\n // Reuse the child provided\n // This makes it flexible to use whatever element is wanted (div, ul, etc)\n return _react2.default.createElement(\n _DraggableCore2.default,\n _extends({}, this.props, { onStart: this.onDragStart, onDrag: this.onDrag, onStop: this.onDragStop }),\n _react2.default.cloneElement(_react2.default.Children.only(this.props.children), {\n className: className,\n style: _extends({}, this.props.children.props.style, style),\n transform: svgTransform\n })\n );\n }\n }]);\n\n return Draggable;\n}(_react2.default.Component);\n\nDraggable.displayName = 'Draggable';\nDraggable.propTypes = _extends({}, _DraggableCore2.default.propTypes, {\n\n /**\n * `axis` determines which axis the draggable can move.\n *\n * Note that all callbacks will still return data as normal. This only\n * controls flushing to the DOM.\n *\n * 'both' allows movement horizontally and vertically.\n * 'x' limits movement to horizontal axis.\n * 'y' limits movement to vertical axis.\n * 'none' limits all movement.\n *\n * Defaults to 'both'.\n */\n axis: _propTypes2.default.oneOf(['both', 'x', 'y', 'none']),\n\n /**\n * `bounds` determines the range of movement available to the element.\n * Available values are:\n *\n * 'parent' restricts movement within the Draggable's parent node.\n *\n * Alternatively, pass an object with the following properties, all of which are optional:\n *\n * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n *\n * All values are in px.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
Content
\n * \n * );\n * }\n * });\n * ```\n */\n bounds: _propTypes2.default.oneOfType([_propTypes2.default.shape({\n left: _propTypes2.default.number,\n right: _propTypes2.default.number,\n top: _propTypes2.default.number,\n bottom: _propTypes2.default.number\n }), _propTypes2.default.string, _propTypes2.default.oneOf([false])]),\n\n defaultClassName: _propTypes2.default.string,\n defaultClassNameDragging: _propTypes2.default.string,\n defaultClassNameDragged: _propTypes2.default.string,\n\n /**\n * `defaultPosition` specifies the x and y that the dragged item should start at\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
I start with transformX: 25px and transformY: 25px;
\n * \n * );\n * }\n * });\n * ```\n */\n defaultPosition: _propTypes2.default.shape({\n x: _propTypes2.default.number,\n y: _propTypes2.default.number\n }),\n\n /**\n * `position`, if present, defines the current position of the element.\n *\n * This is similar to how form elements in React work - if no `position` is supplied, the component\n * is uncontrolled.\n *\n * Example:\n *\n * ```jsx\n * let App = React.createClass({\n * render: function () {\n * return (\n * \n *
I start with transformX: 25px and transformY: 25px;
\n * \n * );\n * }\n * });\n * ```\n */\n position: _propTypes2.default.shape({\n x: _propTypes2.default.number,\n y: _propTypes2.default.number\n }),\n\n /**\n * These properties should be defined on the child, not here.\n */\n className: _shims.dontSetMe,\n style: _shims.dontSetMe,\n transform: _shims.dontSetMe\n});\nDraggable.defaultProps = _extends({}, _DraggableCore2.default.defaultProps, {\n axis: 'both',\n bounds: false,\n defaultClassName: 'react-draggable',\n defaultClassNameDragging: 'react-draggable-dragging',\n defaultClassNameDragged: 'react-draggable-dragged',\n defaultPosition: { x: 0, y: 0 },\n position: null\n});\nexports.default = Draggable;\n\n/***/ }),\n/* 14 */\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__(1);\nvar invariant = __webpack_require__(2);\nvar warning = __webpack_require__(8);\n\nvar ReactPropTypesSecret = __webpack_require__(3);\nvar checkPropTypes = __webpack_require__(15);\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n /* global Symbol */\n var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n /**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\n function getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n }\n\n /**\n * Collection of methods that allow declaration and validation of props that are\n * supplied to React components. Example usage:\n *\n * var Props = require('ReactPropTypes');\n * var MyArticle = React.createClass({\n * propTypes: {\n * // An optional string prop named \"description\".\n * description: Props.string,\n *\n * // A required enum prop named \"category\".\n * category: Props.oneOf(['News','Photos']).isRequired,\n *\n * // A prop named \"dialog\" that requires an instance of Dialog.\n * dialog: Props.instanceOf(Dialog).isRequired\n * },\n * render: function() { ... }\n * });\n *\n * A more formal specification of how these methods are used:\n *\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n * decl := ReactPropTypes.{type}(.isRequired)?\n *\n * Each and every declaration produces a function with the same signature. This\n * allows the creation of custom validation functions. For example:\n *\n * var MyLink = React.createClass({\n * propTypes: {\n * // An optional string or URI prop named \"href\".\n * href: function(props, propName, componentName) {\n * var propValue = props[propName];\n * if (propValue != null && typeof propValue !== 'string' &&\n * !(propValue instanceof URI)) {\n * return new Error(\n * 'Expected a string or an URI for ' + propName + ' in ' +\n * componentName\n * );\n * }\n * }\n * },\n * render: function() {...}\n * });\n *\n * @internal\n */\n\n var ANONYMOUS = '<>';\n\n // Important!\n // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n var ReactPropTypes = {\n array: createPrimitiveTypeChecker('array'),\n bool: createPrimitiveTypeChecker('boolean'),\n func: createPrimitiveTypeChecker('function'),\n number: createPrimitiveTypeChecker('number'),\n object: createPrimitiveTypeChecker('object'),\n string: createPrimitiveTypeChecker('string'),\n symbol: createPrimitiveTypeChecker('symbol'),\n\n any: createAnyTypeChecker(),\n arrayOf: createArrayOfTypeChecker,\n element: createElementTypeChecker(),\n instanceOf: createInstanceTypeChecker,\n node: createNodeChecker(),\n objectOf: createObjectOfTypeChecker,\n oneOf: createEnumTypeChecker,\n oneOfType: createUnionTypeChecker,\n shape: createShapeTypeChecker\n };\n\n /**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\n /*eslint-disable no-self-compare*/\n function is(x, y) {\n // SameValue algorithm\n if (x === y) {\n // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n return x !== 0 || 1 / x === 1 / y;\n } else {\n // Step 6.a: NaN == NaN\n return x !== x && y !== y;\n }\n }\n /*eslint-enable no-self-compare*/\n\n /**\n * We use an Error-like object for backward compatibility as people may call\n * PropTypes directly and inspect their output. However, we don't use real\n * Errors anymore. We don't inspect their stack anyway, and creating them\n * is prohibitively expensive if they are created too often, such as what\n * happens in oneOfType() for any type before the one that matched.\n */\n function PropTypeError(message) {\n this.message = message;\n this.stack = '';\n }\n // Make `instanceof Error` still work for returned errors.\n PropTypeError.prototype = Error.prototype;\n\n function createChainableTypeChecker(validate) {\n if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var manualPropTypeCallCache = {};\n var manualPropTypeWarningCount = 0;\n }\n function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n componentName = componentName || ANONYMOUS;\n propFullName = propFullName || propName;\n\n if (secret !== ReactPropTypesSecret) {\n if (throwOnDirectAccess) {\n // New behavior only for users of `prop-types` package\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 } else if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' && typeof console !== 'undefined') {\n // Old behavior for people using React.PropTypes\n var cacheKey = componentName + ':' + propName;\n if (\n !manualPropTypeCallCache[cacheKey] &&\n // Avoid spamming the console because they are often not actionable except for lib authors\n manualPropTypeWarningCount < 3\n ) {\n warning(\n false,\n 'You are manually calling a React.PropTypes validation ' +\n 'function for the `%s` prop on `%s`. This is deprecated ' +\n 'and will throw in the standalone `prop-types` package. ' +\n 'You may be seeing this warning due to a third-party PropTypes ' +\n 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',\n propFullName,\n componentName\n );\n manualPropTypeCallCache[cacheKey] = true;\n manualPropTypeWarningCount++;\n }\n }\n }\n if (props[propName] == null) {\n if (isRequired) {\n if (props[propName] === null) {\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n }\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n }\n return null;\n } else {\n return validate(props, propName, componentName, location, propFullName);\n }\n }\n\n var chainedCheckType = checkType.bind(null, false);\n chainedCheckType.isRequired = checkType.bind(null, true);\n\n return chainedCheckType;\n }\n\n function createPrimitiveTypeChecker(expectedType) {\n function validate(props, propName, componentName, location, propFullName, secret) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== expectedType) {\n // `propValue` being instance of, say, date/regexp, pass the 'object'\n // check, but we can offer a more precise error message here rather than\n // 'of type `object`'.\n var preciseType = getPreciseType(propValue);\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createAnyTypeChecker() {\n return createChainableTypeChecker(emptyFunction.thatReturnsNull);\n }\n\n function createArrayOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n }\n var propValue = props[propName];\n if (!Array.isArray(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n }\n for (var i = 0; i < propValue.length; i++) {\n var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createElementTypeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n if (!isValidElement(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createInstanceTypeChecker(expectedClass) {\n function validate(props, propName, componentName, location, propFullName) {\n if (!(props[propName] instanceof expectedClass)) {\n var expectedClassName = expectedClass.name || ANONYMOUS;\n var actualClassName = getClassName(props[propName]);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createEnumTypeChecker(expectedValues) {\n if (!Array.isArray(expectedValues)) {\n Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n for (var i = 0; i < expectedValues.length; i++) {\n if (is(propValue, expectedValues[i])) {\n return null;\n }\n }\n\n var valuesString = JSON.stringify(expectedValues);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createObjectOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n }\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n }\n for (var key in propValue) {\n if (propValue.hasOwnProperty(key)) {\n var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createUnionTypeChecker(arrayOfTypeCheckers) {\n if (!Array.isArray(arrayOfTypeCheckers)) {\n Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (typeof checker !== 'function') {\n warning(\n false,\n 'Invalid argument supplid to oneOfType. Expected an array of check functions, but ' +\n 'received %s at index %s.',\n getPostfixForTypeWarning(checker),\n i\n );\n return emptyFunction.thatReturnsNull;\n }\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n return null;\n }\n }\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createNodeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n if (!isNode(props[propName])) {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createShapeTypeChecker(shapeTypes) {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n }\n for (var key in shapeTypes) {\n var checker = shapeTypes[key];\n if (!checker) {\n continue;\n }\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function isNode(propValue) {\n switch (typeof propValue) {\n case 'number':\n case 'string':\n case 'undefined':\n return true;\n case 'boolean':\n return !propValue;\n case 'object':\n if (Array.isArray(propValue)) {\n return propValue.every(isNode);\n }\n if (propValue === null || isValidElement(propValue)) {\n return true;\n }\n\n var iteratorFn = getIteratorFn(propValue);\n if (iteratorFn) {\n var iterator = iteratorFn.call(propValue);\n var step;\n if (iteratorFn !== propValue.entries) {\n while (!(step = iterator.next()).done) {\n if (!isNode(step.value)) {\n return false;\n }\n }\n } else {\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n if (!isNode(entry[1])) {\n return false;\n }\n }\n }\n }\n } else {\n return false;\n }\n\n return true;\n default:\n return false;\n }\n }\n\n function isSymbol(propType, propValue) {\n // Native Symbol.\n if (propType === 'symbol') {\n return true;\n }\n\n // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n if (propValue['@@toStringTag'] === 'Symbol') {\n return true;\n }\n\n // Fallback for non-spec compliant Symbols which are polyfilled.\n if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n return true;\n }\n\n return false;\n }\n\n // Equivalent of `typeof` but with special handling for array and regexp.\n function getPropType(propValue) {\n var propType = typeof propValue;\n if (Array.isArray(propValue)) {\n return 'array';\n }\n if (propValue instanceof RegExp) {\n // Old webkits (at least until Android 4.0) return 'function' rather than\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n // passes PropTypes.object.\n return 'object';\n }\n if (isSymbol(propType, propValue)) {\n return 'symbol';\n }\n return propType;\n }\n\n // This handles more types than `getPropType`. Only used for error messages.\n // See `createPrimitiveTypeChecker`.\n function getPreciseType(propValue) {\n if (typeof propValue === 'undefined' || propValue === null) {\n return '' + propValue;\n }\n var propType = getPropType(propValue);\n if (propType === 'object') {\n if (propValue instanceof Date) {\n return 'date';\n } else if (propValue instanceof RegExp) {\n return 'regexp';\n }\n }\n return propType;\n }\n\n // Returns a string that is postfixed to a warning about an invalid type.\n // For example, \"undefined\" or \"of type array\"\n function getPostfixForTypeWarning(value) {\n var type = getPreciseType(value);\n switch (type) {\n case 'array':\n case 'object':\n return 'an ' + type;\n case 'boolean':\n case 'date':\n case 'regexp':\n return 'a ' + type;\n default:\n return type;\n }\n }\n\n // Returns class name of the object, if any.\n function getClassName(propValue) {\n if (!propValue.constructor || !propValue.constructor.name) {\n return ANONYMOUS;\n }\n return propValue.constructor.name;\n }\n\n ReactPropTypes.checkPropTypes = checkPropTypes;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\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\nif (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n var invariant = __webpack_require__(2);\n var warning = __webpack_require__(8);\n var ReactPropTypesSecret = __webpack_require__(3);\n var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n if (Object({\"DRAGGABLE_DEBUG\":undefined}).NODE_ENV !== 'production') {\n for (var typeSpecName in typeSpecs) {\n if (typeSpecs.hasOwnProperty(typeSpecName)) {\n var error;\n // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', location, typeSpecName);\n error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n } catch (ex) {\n error = ex;\n }\n warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var stack = getStack ? getStack() : '';\n\n warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n }\n }\n }\n }\n}\n\nmodule.exports = checkPropTypes;\n\n\n/***/ }),\n/* 16 */\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__(1);\nvar invariant = __webpack_require__(2);\nvar ReactPropTypesSecret = __webpack_require__(3);\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n 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 // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n 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/* 17 */\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/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.getPrefix = getPrefix;\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\nfunction getPrefix() /*: string*/ {\n var prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n\n // Checking specifically for 'window.document' is for pseudo-browser server-side\n // environments that define 'window' as the global context.\n // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n\n var style = window.document.documentElement.style;\n\n if (prop in style) return '';\n\n for (var i = 0; i < prefixes.length; i++) {\n if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n }\n\n return '';\n}\n\nfunction browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n return prefix ? '' + prefix + kebabToTitleCase(prop) : prop;\n}\n\nfunction browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/ {\n return prefix ? '-' + prefix.toLowerCase() + '-' + prop : prop;\n}\n\nfunction kebabToTitleCase(str /*: string*/) /*: string*/ {\n var out = '';\n var shouldCapitalize = true;\n for (var i = 0; i < str.length; i++) {\n if (shouldCapitalize) {\n out += str[i].toUpperCase();\n shouldCapitalize = false;\n } else if (str[i] === '-') {\n shouldCapitalize = true;\n } else {\n out += str[i];\n }\n }\n return out;\n}\n\n// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\nexports.default = getPrefix();\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // 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 return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // 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 return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // 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 return cachedClearTimeout.call(null, marker);\n } catch (e){\n // 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 // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=react-draggable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/react-draggable/dist/react-draggable.js\n// module id = 6\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_7__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}\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 _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\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\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) {\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, height, aspectRatio) {\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, height) {\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) {\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\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() {\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: _propTypes2.default.element.isRequired,\n\n // Initial w/h\n width: _propTypes2.default.number.isRequired,\n height: _propTypes2.default.number.isRequired,\n\n //\n // Optional props\n //\n\n // If you change this, be sure to update your css\n handleSize: _propTypes2.default.array,\n\n // If true, will only allow width/height to move in lockstep\n lockAspectRatio: _propTypes2.default.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: _propTypes2.default.oneOf(['both', 'x', 'y', 'none']),\n\n // Min/max size\n minConstraints: _propTypes2.default.arrayOf(_propTypes2.default.number),\n maxConstraints: _propTypes2.default.arrayOf(_propTypes2.default.number),\n\n // Callbacks\n onResizeStop: _propTypes2.default.func,\n onResizeStart: _propTypes2.default.func,\n onResize: _propTypes2.default.func,\n\n // These will be passed wholesale to react-draggable's DraggableCore\n draggableOpts: _propTypes2.default.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// ./node_modules/react-resizable/build/Resizable.js\n// module id = 8\n// module chunks = 0","// @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","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","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n 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 // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim,\n exact: getShim\n };\n\n ReactPropTypes.checkPropTypes = emptyFunction;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/prop-types/factoryWithThrowingShims.js\n// module id = 11\n// module chunks = 0","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\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// ./node_modules/fbjs/lib/emptyFunction.js\n// module id = 12\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\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// ./node_modules/fbjs/lib/invariant.js\n// module id = 13\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/prop-types/lib/ReactPropTypesSecret.js\n// module id = 14\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 = 15\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 = 16\n// module chunks = 0","// @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';\nimport type {Element as ReactElement, Node as ReactNode} from 'react';\n\nimport type {ReactDraggableCallbackData, GridDragEvent, GridResizeEvent, Position} from './utils';\n\ntype PartialPosition = {top: number, left: number};\ntype GridItemCallback = (i: string, w: number, h: number, Data) => void;\n\ntype State = {\n resizing: ?{width: number, height: number},\n dragging: ?{top: number, left: number},\n className: string\n};\n\ntype Props = {\n children: ReactElement,\n cols: number,\n containerWidth: number,\n margin: [number, number],\n containerPadding: [number, number],\n rowHeight: number,\n maxRows: number,\n isDraggable: boolean,\n isResizable: boolean,\n static?: boolean,\n useCSSTransforms?: boolean,\n usePercentages?: boolean,\n\n className: string,\n style?: Object,\n // Draggability\n cancel: string,\n handle: string,\n\n x: number,\n y: number,\n w: number,\n h: number,\n\n minW: number,\n maxW: number,\n minH: number,\n maxH: number,\n i: string,\n\n onDrag?: GridItemCallback,\n onDragStart?: GridItemCallback,\n onDragStop?: GridItemCallback,\n onResize?: GridItemCallback,\n onResizeStart?: GridItemCallback,\n onResizeStop?: GridItemCallback,\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 handle: '',\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: ReactElement): ReactElement {\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: ReactElement, position: Position): ReactElement {\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}: ReactDraggableCallbackData) => {\n const handler = this.props[handlerName];\n if (!handler) return;\n\n const newPosition: PartialPosition = {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 + node.offsetParent.scrollLeft;\n newPosition.top = clientRect.top - parentRect.top + node.offsetParent.scrollTop;\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 handler.call(this, 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 const handler = this.props[handlerName];\n if (!handler) 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 handler.call(this, i, w, h, {e, node, size});\n };\n }\n\n render(): ReactNode {\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';\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// ./node_modules/react-resizable/index.js\n// module id = 18\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, props) {\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// ./node_modules/react-resizable/build/cloneElement.js\n// module id = 19\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 _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\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// An example use of Resizable.\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, data) {\n var size = data.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 && _this.props.onResize(e, data);\n });\n } else {\n _this.setState(size);\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n ResizableBox.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\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() {\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: _propTypes2.default.number,\n width: _propTypes2.default.number\n};\nResizableBox.defaultProps = {\n handleSize: [20, 20]\n};\nexports.default = ResizableBox;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/react-resizable/build/ResizableBox.js\n// module id = 20\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';\nimport type {Props as RGLProps} from './ReactGridLayout';\nimport type {Layout} from './utils';\n\nconst noop = function(){};\nconst type = (obj) => Object.prototype.toString.call(obj);\n\ntype State = {\n layout: Layout,\n breakpoint: string,\n cols: number\n};\n\ntype Props = {\n ...$Exact,\n\n // Responsive config\n breakpoint: Breakpoint,\n breakpoints: {[key: Breakpoint]: number},\n cols: {[key: Breakpoint]: number},\n layouts: {[key: Breakpoint]: Layout},\n width: number,\n\n // Callbacks\n onBreakpointChange: (Breakpoint, cols: number) => void,\n onLayoutChange: (Layout, {[key: Breakpoint]: Layout}) => void,\n onWidthChange:\n (containerWidth: number, margin: [number, number], cols: number, containerPadding: [number, number]) => void\n};\n\nexport default class ResponsiveReactGridLayout extends React.Component, State> {\n\n // This should only include propTypes needed in this code; RGL itself\n // will do validation of the rest props passed to it.\n static propTypes = {\n\n //\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 = 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: Props<*>) {\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: 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';\nimport type {ComponentType as ReactComponentType} from 'react';\n\ntype Props = {\n className?: string,\n measureBeforeMount: boolean,\n style?: Object,\n};\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: ReactComponentType) => ReactComponentType;\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"],"sourceRoot":""}