@reltio/remotes 1.4.1521 → 1.4.1523

package/6244.js.map

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