{"version":3,"sources":["../webpack/universalModuleDefinition","../webpack/bootstrap 15089f105fec648c1f75",".././index.js",".././lib/Draggable.es6","../external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}",".././~/prop-types/index.js",".././~/prop-types/factoryWithTypeCheckers.js",".././~/fbjs/lib/emptyFunction.js",".././~/fbjs/lib/invariant.js",".././~/fbjs/lib/warning.js",".././~/prop-types/lib/ReactPropTypesSecret.js",".././~/prop-types/checkPropTypes.js",".././~/prop-types/factoryWithThrowingShims.js","../external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}",".././~/classnames/index.js",".././lib/utils/domFns.es6",".././lib/utils/shims.es6",".././lib/utils/getPrefix.es6",".././lib/utils/positionFns.es6",".././lib/DraggableCore.es6",".././~/process/browser.js",".././lib/utils/log.es6"],"names":["module","exports","require","default","DraggableCore","Draggable","props","onDragStart","e","coreData","shouldStart","onStart","setState","dragging","dragged","onDrag","state","uiData","newState","x","y","bounds","slackX","slackY","deltaX","deltaY","shouldUpdate","onDragStop","shouldStop","onStop","controlled","Boolean","position","defaultPosition","isElementSVG","console","warn","SVGElement","findDOMNode","nextProps","style","svgTransform","draggable","transformOpts","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","className","children","cloneElement","Children","only","transform","Component","displayName","propTypes","axis","oneOf","oneOfType","shape","left","number","right","top","bottom","string","defaultProps","matchesSelector","matchesSelectorAndParentsTo","addEvent","removeEvent","outerHeight","outerWidth","innerHeight","innerWidth","offsetXYFromParent","createCSSTransform","createSVGTransform","getTouch","getTouchIdentifier","addUserSelectStyles","removeUserSelectStyles","styleHacks","matchesSelectorFunc","el","selector","method","call","baseNode","node","parentNode","event","handler","attachEvent","addEventListener","detachEvent","removeEventListener","height","clientHeight","computedStyle","ownerDocument","defaultView","getComputedStyle","borderTopWidth","borderBottomWidth","width","clientWidth","borderLeftWidth","borderRightWidth","paddingTop","paddingBottom","paddingLeft","paddingRight","evt","offsetParent","isBody","body","offsetParentRect","getBoundingClientRect","clientX","scrollLeft","clientY","scrollTop","identifier","targetTouches","t","changedTouches","userSelectPrefix","userSelect","userSelectStyle","userSelectReplaceRegExp","RegExp","getAttribute","test","setAttribute","replace","childStyle","touchAction","findInArray","isFunction","isNum","int","dontSetMe","array","callback","i","length","apply","func","Object","prototype","toString","num","isNaN","a","parseInt","propName","componentName","Error","getPrefix","browserPrefixToKey","browserPrefixToStyle","prefixes","prop","window","document","documentElement","prefix","kebabToTitleCase","toLowerCase","str","out","shouldCapitalize","toUpperCase","getBoundPosition","snapToGrid","canDragX","canDragY","getControlPosition","createCoreData","createDraggableData","cloneBounds","ownerWindow","boundNode","querySelector","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","marginRight","marginBottom","Math","min","max","grid","pendingX","pendingY","round","touchIdentifier","draggableCore","touchObj","isStart","lastX","lastY","eventsFor","touch","start","move","stop","mouse","dragEventFor","NaN","handleDragStart","onMouseDown","allowAnyClick","button","domNode","disabled","target","Node","handle","cancel","coreEvent","enableUserSelectHack","handleDrag","handleDragStop","type","preventDefault","Array","isArray","MouseEvent","err","createEvent","initMouseEvent","onMouseUp","onTouchStart","onTouchEnd","bool","process","browser","nodeType","arrayOf","log"],"mappings":"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;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;;;;;;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,2CAA0C;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,QAAQ;AACrB,eAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAU;AACV,8BAA6B;AAC7B,SAAQ;AACR;AACA;AACA;AACA;AACA,gCAA+B,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT,6BAA4B;AAC5B,QAAO;AACP;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB,sBAAsB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sBAAqB,2BAA2B;AAChD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,sBAAqB,gCAAgC;AACrD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;AC7dA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,8CAA6C;AAC7C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,gC;;;;;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,sDAAqD;AACrD,MAAK;AACL;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;;AAEA,2BAA0B;AAC1B;AACA;AACA;;AAEA,4B;;;;;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,yFAAwF,aAAa;AACrG;AACA;;AAEA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;;AAEA;AACA,gBAAe;AACf;;AAEA;AACA,+FAA8F,eAAe;AAC7G;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;;AAEA,0B;;;;;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,UAAU;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,4BAA2B;AAC3B;AACA;AACA;AACA,6BAA4B,UAAU;;;;;;;;;;;;mBCjLdgP,G;;AADxB;AACe,UAASA,GAAT,GAA2B;AAAA;;AACxC,OAAI,WAAJ,EAAiC,qBAAQA,GAAR;AAClC,E","file":"./dist/react-draggable.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"), require(\"react-dom\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\", \"react-dom\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactDraggable\"] = factory(require(\"react\"), require(\"react-dom\"));\n\telse\n\t\troot[\"ReactDraggable\"] = factory(root[\"React\"], root[\"ReactDOM\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_11__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 15089f105fec648c1f75","module.exports = require('./lib/Draggable').default;\nmodule.exports.DraggableCore = require('./lib/DraggableCore').default;\n\n\n\n// WEBPACK FOOTER //\n// ./index.js","// @flow\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport ReactDOM from 'react-dom';\n// $FlowIgnore\nimport classNames from 'classnames';\nimport {createCSSTransform, createSVGTransform} from './utils/domFns';\nimport {canDragX, canDragY, createDraggableData, getBoundPosition} from './utils/positionFns';\nimport {dontSetMe} from './utils/shims';\nimport DraggableCore from './DraggableCore';\nimport log from './utils/log';\nimport type {DraggableEventHandler} from './utils/types';\n\ntype DraggableState = {\n  dragging: boolean,\n  dragged: boolean,\n  x: number, y: number,\n  slackX: number, slackY: number,\n  isElementSVG: boolean\n};\n\ntype ConstructorProps = {\n  position: { x: number, y: number },\n  defaultPosition: { x: number, y: number }\n};\n\n//\n// Define <Draggable>\n//\n\nexport default class Draggable extends React.Component {\n\n  static displayName = 'Draggable';\n\n  static propTypes = {\n    // Accepts all props <DraggableCore> accepts.\n    ...DraggableCore.propTypes,\n\n    /**\n     * `axis` determines which axis the draggable can move.\n     *\n     *  Note that all callbacks will still return data as normal. This only\n     *  controls flushing to the DOM.\n     *\n     * 'both' allows movement horizontally and vertically.\n     * 'x' limits movement to horizontal axis.\n     * 'y' limits movement to vertical axis.\n     * 'none' limits all movement.\n     *\n     * Defaults to 'both'.\n     */\n    axis: PropTypes.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.oneOfType([\n      PropTypes.shape({\n        left: PropTypes.number,\n        right: PropTypes.number,\n        top: PropTypes.number,\n        bottom: PropTypes.number\n      }),\n      PropTypes.string,\n      PropTypes.oneOf([false])\n    ]),\n\n    defaultClassName: PropTypes.string,\n    defaultClassNameDragging: PropTypes.string,\n    defaultClassNameDragged: PropTypes.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.shape({\n      x: PropTypes.number,\n      y: PropTypes.number\n    }),\n\n    /**\n     * `position`, if present, defines the current position of the element.\n     *\n     *  This is similar to how form elements in React work - if no `position` is supplied, the component\n     *  is uncontrolled.\n     *\n     * Example:\n     *\n     * ```jsx\n     *      let App = React.createClass({\n     *          render: function () {\n     *              return (\n     *                  <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.shape({\n      x: PropTypes.number,\n      y: PropTypes.number\n    }),\n\n    /**\n     * These properties should be defined on the child, not here.\n     */\n    className: dontSetMe,\n    style: dontSetMe,\n    transform: dontSetMe\n  };\n\n  static defaultProps = {\n    ...DraggableCore.defaultProps,\n    axis: 'both',\n    bounds: false,\n    defaultClassName: 'react-draggable',\n    defaultClassNameDragging: 'react-draggable-dragging',\n    defaultClassNameDragged: 'react-draggable-dragged',\n    defaultPosition: {x: 0, y: 0},\n    position: null\n  };\n\n  state: DraggableState;\n\n  constructor(props: ConstructorProps) {\n    super(props);\n\n    this.state = {\n      // Whether or not we are currently dragging.\n      dragging: false,\n\n      // Whether or not we have been dragged before.\n      dragged: false,\n\n      // Current transform x and y.\n      x: props.position ? props.position.x : props.defaultPosition.x,\n      y: props.position ? props.position.y : props.defaultPosition.y,\n\n      // Used for compensating for out-of-bounds drags\n      slackX: 0, slackY: 0,\n\n      // Can only determine if SVG after mounting\n      isElementSVG: false\n    };\n  }\n\n  componentWillMount() {\n    if (this.props.position && !(this.props.onDrag || this.props.onStop)) {\n      // eslint-disable-next-line\n      console.warn('A `position` was applied to this <Draggable>, without drag handlers. This will make this ' +\n        'component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the ' +\n        '`position` of this element.');\n    }\n  }\n\n  componentDidMount() {\n    // Check to see if the element passed is an instanceof SVGElement\n    if(typeof SVGElement !== 'undefined' && ReactDOM.findDOMNode(this) instanceof SVGElement) {\n      this.setState({ isElementSVG: true });\n    }\n  }\n\n  componentWillReceiveProps(nextProps: Object) {\n    // Set x/y if position has changed\n    if (nextProps.position &&\n        (!this.props.position ||\n          nextProps.position.x !== this.props.position.x ||\n          nextProps.position.y !== this.props.position.y\n        )\n      ) {\n      this.setState({ x: nextProps.position.x, y: nextProps.position.y });\n    }\n  }\n\n  componentWillUnmount() {\n    this.setState({dragging: false}); // prevents invariant if unmounted while dragging\n  }\n\n  onDragStart: DraggableEventHandler = (e, coreData) => {\n    log('Draggable: onDragStart: %j', coreData);\n\n    // Short-circuit if user's callback killed it.\n    const shouldStart = this.props.onStart(e, createDraggableData(this, coreData));\n    // Kills start event on core as well, so move handlers are never bound.\n    if (shouldStart === false) return false;\n\n    this.setState({dragging: true, dragged: true});\n  };\n\n  onDrag: DraggableEventHandler = (e, coreData) => {\n    if (!this.state.dragging) return false;\n    log('Draggable: onDrag: %j', coreData);\n\n    const uiData = createDraggableData(this, coreData);\n\n    const newState: $Shape<DraggableState> = {\n      x: uiData.x,\n      y: uiData.y\n    };\n\n    // Keep within bounds.\n    if (this.props.bounds) {\n      // Save original x and y.\n      const {x, y} = newState;\n\n      // Add slack to the values used to calculate bound position. This will ensure that if\n      // we start removing slack, the element won't react to it right away until it's been\n      // completely removed.\n      newState.x += this.state.slackX;\n      newState.y += this.state.slackY;\n\n      // Get bound position. This will ceil/floor the x and y within the boundaries.\n      // $FlowBug\n      [newState.x, newState.y] = getBoundPosition(this, newState.x, newState.y);\n\n      // Recalculate slack by noting how much was shaved by the boundPosition handler.\n      newState.slackX = this.state.slackX + (x - newState.x);\n      newState.slackY = this.state.slackY + (y - newState.y);\n\n      // Update the event we fire to reflect what really happened after bounds took effect.\n      uiData.x = x;\n      uiData.y = y;\n      uiData.deltaX = newState.x - this.state.x;\n      uiData.deltaY = newState.y - this.state.y;\n    }\n\n    // Short-circuit if user's callback killed it.\n    const shouldUpdate = this.props.onDrag(e, uiData);\n    if (shouldUpdate === false) return false;\n\n    this.setState(newState);\n  };\n\n  onDragStop: DraggableEventHandler = (e, coreData) => {\n    if (!this.state.dragging) return false;\n\n    // Short-circuit if user's callback killed it.\n    const shouldStop = this.props.onStop(e, createDraggableData(this, coreData));\n    if (shouldStop === false) return false;\n\n    log('Draggable: onDragStop: %j', coreData);\n\n    const newState: $Shape<DraggableState> = {\n      dragging: false,\n      slackX: 0,\n      slackY: 0\n    };\n\n    // If this is a controlled component, the result of this operation will be to\n    // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n    const controlled = Boolean(this.props.position);\n    if (controlled) {\n      const {x, y} = this.props.position;\n      newState.x = x;\n      newState.y = y;\n    }\n\n    this.setState(newState);\n  };\n\n  render(): React.Element<any> {\n    let style = {}, svgTransform = null;\n\n    // If this is controlled, we don't want to move it - unless it's dragging.\n    const controlled = Boolean(this.props.position);\n    const draggable = !controlled || this.state.dragging;\n\n    const position = this.props.position || this.props.defaultPosition;\n    const transformOpts = {\n      // Set left if horizontal drag is enabled\n      x: canDragX(this) && draggable ?\n        this.state.x :\n        position.x,\n\n      // Set top if vertical drag is enabled\n      y: canDragY(this) && draggable ?\n        this.state.y :\n        position.y\n    };\n\n    // If this element was SVG, we use the `transform` attribute.\n    if (this.state.isElementSVG) {\n      svgTransform = createSVGTransform(transformOpts);\n    } else {\n      // Add a CSS transform to move the element around. This allows us to move the element around\n      // without worrying about whether or not it is relatively or absolutely positioned.\n      // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>\n      // has a clean slate.\n      style = createCSSTransform(transformOpts);\n    }\n\n    const {\n      defaultClassName,\n      defaultClassNameDragging,\n      defaultClassNameDragged\n    } = this.props;\n\n    // Mark with class while dragging\n    const className = classNames((this.props.children.props.className || ''), defaultClassName, {\n      [defaultClassNameDragging]: this.state.dragging,\n      [defaultClassNameDragged]: this.state.dragged\n    });\n\n    // Reuse the child provided\n    // This makes it flexible to use whatever element is wanted (div, ul, etc)\n    return (\n      <DraggableCore {...this.props} onStart={this.onDragStart} onDrag={this.onDrag} onStop={this.onDragStop}>\n        {React.cloneElement(React.Children.only(this.props.children), {\n          className: className,\n          style: {...this.props.children.props.style, ...style},\n          transform: svgTransform\n        })}\n      </DraggableCore>\n    );\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/Draggable.es6","module.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"commonjs\":\"react\",\"commonjs2\":\"react\",\"amd\":\"react\",\"root\":\"React\"}\n// module id = 2\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n    Symbol.for &&\n    Symbol.for('react.element')) ||\n    0xeac7;\n\n  var isValidElement = function(object) {\n    return typeof object === 'object' &&\n      object !== null &&\n      object.$$typeof === REACT_ELEMENT_TYPE;\n  };\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/index.js\n// module id = 3\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar checkPropTypes = require('./checkPropTypes');\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message) {\n    this.message = message;\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          invariant(\n            false,\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            warning(\n              false,\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `%s` prop on `%s`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',\n              propFullName,\n              componentName\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunction.thatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n      return emptyFunction.thatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues);\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (propValue.hasOwnProperty(key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunction.thatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n          return null;\n        }\n      }\n\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (!checker) {\n          continue;\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/factoryWithTypeCheckers.js\n// module id = 4\n// module chunks = 0","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/fbjs/lib/emptyFunction.js\n// module id = 5\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/fbjs/lib/invariant.js\n// module id = 6\n// module chunks = 0","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\nvar emptyFunction = require('./emptyFunction');\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (process.env.NODE_ENV !== 'production') {\n  (function () {\n    var printWarning = function printWarning(format) {\n      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n\n      var argIndex = 0;\n      var message = 'Warning: ' + format.replace(/%s/g, function () {\n        return args[argIndex++];\n      });\n      if (typeof console !== 'undefined') {\n        console.error(message);\n      }\n      try {\n        // --- Welcome to debugging React ---\n        // This error was thrown as a convenience so that you can use this stack\n        // to find the callsite that caused this warning to fire.\n        throw new Error(message);\n      } catch (x) {}\n    };\n\n    warning = function warning(condition, format) {\n      if (format === undefined) {\n        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n      }\n\n      if (format.indexOf('Failed Composite propType: ') === 0) {\n        return; // Ignore CompositeComponent proptype check.\n      }\n\n      if (!condition) {\n        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n          args[_key2 - 2] = arguments[_key2];\n        }\n\n        printWarning.apply(undefined, [format].concat(args));\n      }\n    };\n  })();\n}\n\nmodule.exports = warning;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/fbjs/lib/warning.js\n// module id = 7\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/lib/ReactPropTypesSecret.js\n// module id = 8\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== 'production') {\n  var invariant = require('fbjs/lib/invariant');\n  var warning = require('fbjs/lib/warning');\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (typeSpecs.hasOwnProperty(typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', location, typeSpecName);\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n        }\n      }\n    }\n  }\n}\n\nmodule.exports = checkPropTypes;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/checkPropTypes.js\n// module id = 9\n// module chunks = 0","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\n\nmodule.exports = function() {\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  function shim() {\n    invariant(\n      false,\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim\n  };\n\n  ReactPropTypes.checkPropTypes = emptyFunction;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/factoryWithThrowingShims.js\n// module id = 10\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_11__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"commonjs\":\"react-dom\",\"commonjs2\":\"react-dom\",\"amd\":\"react-dom\",\"root\":\"ReactDOM\"}\n// module id = 11\n// module chunks = 0","/*!\n  Copyright (c) 2016 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/classnames/index.js\n// module id = 12\n// module chunks = 0","// @flow\nimport {findInArray, isFunction, int} from './shims';\nimport browserPrefix, {getPrefix, browserPrefixToStyle, browserPrefixToKey} from './getPrefix';\n\nimport type {ControlPosition} from './types';\n\nlet matchesSelectorFunc = '';\nexport function matchesSelector(el: Node, selector: string): boolean {\n  if (!matchesSelectorFunc) {\n    matchesSelectorFunc = findInArray([\n      'matches',\n      'webkitMatchesSelector',\n      'mozMatchesSelector',\n      'msMatchesSelector',\n      'oMatchesSelector'\n    ], function(method){\n      // $FlowIgnore: Doesn't think elements are indexable\n      return isFunction(el[method]);\n    });\n  }\n\n  // $FlowIgnore: Doesn't think elements are indexable\n  return el[matchesSelectorFunc].call(el, selector);\n}\n\n// Works up the tree to the draggable itself attempting to match selector.\nexport function matchesSelectorAndParentsTo(el: Node, selector: string, baseNode: Node): boolean {\n  let node = el;\n  do {\n    if (matchesSelector(node, selector)) return true;\n    if (node === baseNode) return false;\n    node = node.parentNode;\n  } while (node);\n\n  return false;\n}\n\nexport function addEvent(el: ?Node, event: string, handler: Function): void {\n  if (!el) { return; }\n  if (el.attachEvent) {\n    el.attachEvent('on' + event, handler);\n  } else if (el.addEventListener) {\n    el.addEventListener(event, handler, true);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = handler;\n  }\n}\n\nexport function removeEvent(el: ?Node, event: string, handler: Function): void {\n  if (!el) { return; }\n  if (el.detachEvent) {\n    el.detachEvent('on' + event, handler);\n  } else if (el.removeEventListener) {\n    el.removeEventListener(event, handler, true);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = null;\n  }\n}\n\nexport function outerHeight(node: HTMLElement): number {\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetTop which is including margin. See getBoundPosition\n  let height = node.clientHeight;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height += int(computedStyle.borderTopWidth);\n  height += int(computedStyle.borderBottomWidth);\n  return height;\n}\n\nexport function outerWidth(node: HTMLElement): number {\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetLeft which is including margin. See getBoundPosition\n  let width = node.clientWidth;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width += int(computedStyle.borderLeftWidth);\n  width += int(computedStyle.borderRightWidth);\n  return width;\n}\nexport function innerHeight(node: HTMLElement): number {\n  let height = node.clientHeight;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height -= int(computedStyle.paddingTop);\n  height -= int(computedStyle.paddingBottom);\n  return height;\n}\n\nexport function innerWidth(node: HTMLElement): number {\n  let width = node.clientWidth;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width -= int(computedStyle.paddingLeft);\n  width -= int(computedStyle.paddingRight);\n  return width;\n}\n\n// Get from offsetParent\nexport function offsetXYFromParent(evt: {clientX: number, clientY: number}, offsetParent: HTMLElement): ControlPosition {\n  const isBody = offsetParent === offsetParent.ownerDocument.body;\n  const offsetParentRect = isBody ? {left: 0, top: 0} : offsetParent.getBoundingClientRect();\n\n  const x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;\n  const y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;\n\n  return {x, y};\n}\n\nexport function createCSSTransform({x, y}: {x: number, y: number}): Object {\n  // Replace unitless items with px\n  return {[browserPrefixToKey('transform', browserPrefix)]: 'translate(' + x + 'px,' + y + 'px)'};\n}\n\nexport function createSVGTransform({x, y}: {x: number, y: number}): string {\n  return 'translate(' + x + ',' + y + ')';\n}\n\nexport function getTouch(e: MouseTouchEvent, identifier: number): ?{clientX: number, clientY: number} {\n  return (e.targetTouches && findInArray(e.targetTouches, t => identifier === t.identifier)) ||\n         (e.changedTouches && findInArray(e.changedTouches, t => identifier === t.identifier));\n}\n\nexport function getTouchIdentifier(e: MouseTouchEvent): ?number {\n  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n}\n\n// User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\nconst userSelectPrefix = getPrefix('user-select');\nconst userSelect = browserPrefixToStyle('user-select', userSelectPrefix);\nconst userSelectStyle = `;${userSelect}: none;`;\nconst userSelectReplaceRegExp = new RegExp(`;?${userSelect}: none;`); // leading ; not present on IE\n\n// Note we're passing `document` b/c we could be iframed\nexport function addUserSelectStyles(body: HTMLElement) {\n  const style = body.getAttribute('style') || '';\n  if (userSelectReplaceRegExp.test(style)) return; // don't add twice\n  body.setAttribute('style', style + userSelectStyle);\n}\n\nexport function removeUserSelectStyles(body: HTMLElement) {\n  const style = body.getAttribute('style') || '';\n  body.setAttribute('style', style.replace(userSelectReplaceRegExp, ''));\n}\n\nexport function styleHacks(childStyle: Object = {}): Object {\n  // Workaround IE pointer events; see #51\n  // https://github.com/mzabriskie/react-draggable/issues/51#issuecomment-103488278\n  return {\n    touchAction: 'none',\n    ...childStyle\n  };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/domFns.es6","// @flow\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nexport function findInArray(array: Array<any> | TouchList, callback: Function): any {\n  for (let i = 0, length = array.length; i < length; i++) {\n    if (callback.apply(callback, [array[i], i, array])) return array[i];\n  }\n}\n\nexport function isFunction(func: any): boolean {\n  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nexport function isNum(num: any): boolean {\n  return typeof num === 'number' && !isNaN(num);\n}\n\nexport function int(a: string): number {\n  return parseInt(a, 10);\n}\n\nexport function dontSetMe(props: Object, propName: string, componentName: string) {\n  if (props[propName]) {\n    return new Error(`Invalid prop ${propName} passed to ${componentName} - do not set this, set it on the child.`);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/shims.es6","// @flow\nconst prefixes = ['Moz', 'Webkit', 'O', 'ms'];\nexport function getPrefix(prop: string='transform'): string {\n  // Checking specifically for 'window.document' is for pseudo-browser server-side\n  // environments that define 'window' as the global context.\n  // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n  if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n\n  const style = window.document.documentElement.style;\n\n  if (prop in style) return '';\n\n  for (let i = 0; i < prefixes.length; i++) {\n    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n  }\n\n  return '';\n}\n\nexport function browserPrefixToKey(prop: string, prefix: string): string {\n  return prefix ? `${prefix}${kebabToTitleCase(prop)}` : prop;\n}\n\nexport function browserPrefixToStyle(prop: string, prefix: string): string {\n  return prefix ? `-${prefix.toLowerCase()}-${prop}` : prop;\n}\n\nfunction kebabToTitleCase(str: string): string {\n  let out = '';\n  let shouldCapitalize = true;\n  for (let i = 0; i < str.length; i++) {\n    if (shouldCapitalize) {\n      out += str[i].toUpperCase();\n      shouldCapitalize = false;\n    } else if (str[i] === '-') {\n      shouldCapitalize = true;\n    } else {\n      out += str[i];\n    }\n  }\n  return out;\n}\n\n// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\nexport default getPrefix();\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/getPrefix.es6","// @flow\nimport {isNum, int} from './shims';\nimport ReactDOM from 'react-dom';\nimport {getTouch, innerWidth, innerHeight, offsetXYFromParent, outerWidth, outerHeight} from './domFns';\n\nimport type Draggable from '../Draggable';\nimport type {Bounds, ControlPosition, DraggableData} from './types';\nimport type DraggableCore from '../DraggableCore';\n\nexport function getBoundPosition(draggable: Draggable, x: number, y: number): [number, number] {\n  // If no bounds, short-circuit and move on\n  if (!draggable.props.bounds) return [x, y];\n\n  // Clone new bounds\n  let {bounds} = draggable.props;\n  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n  const node = ReactDOM.findDOMNode(draggable);\n\n  if (typeof bounds === 'string') {\n    const {ownerDocument} = node;\n    const ownerWindow = ownerDocument.defaultView;\n    let boundNode;\n    if (bounds === 'parent') {\n      boundNode = node.parentNode;\n    } else {\n      boundNode = ownerDocument.querySelector(bounds);\n      if (!boundNode) throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n    }\n    const nodeStyle = ownerWindow.getComputedStyle(node);\n    const boundNodeStyle = ownerWindow.getComputedStyle(boundNode);\n    // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n    bounds = {\n      left: -node.offsetLeft + int(boundNodeStyle.paddingLeft) + int(nodeStyle.marginLeft),\n      top: -node.offsetTop + int(boundNodeStyle.paddingTop) + int(nodeStyle.marginTop),\n      right: innerWidth(boundNode) - outerWidth(node) - node.offsetLeft +\n        int(boundNodeStyle.paddingRight) - int(nodeStyle.marginRight),\n      bottom: innerHeight(boundNode) - outerHeight(node) - node.offsetTop +\n        int(boundNodeStyle.paddingBottom) - int(nodeStyle.marginBottom)\n    };\n  }\n\n  // Keep x and y below right and bottom limits...\n  if (isNum(bounds.right)) x = Math.min(x, bounds.right);\n  if (isNum(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\n  // But above left and top limits.\n  if (isNum(bounds.left)) x = Math.max(x, bounds.left);\n  if (isNum(bounds.top)) y = Math.max(y, bounds.top);\n\n  return [x, y];\n}\n\nexport function snapToGrid(grid: [number, number], pendingX: number, pendingY: number): [number, number] {\n  const x = Math.round(pendingX / grid[0]) * grid[0];\n  const y = Math.round(pendingY / grid[1]) * grid[1];\n  return [x, y];\n}\n\nexport function canDragX(draggable: Draggable): boolean {\n  return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nexport function canDragY(draggable: Draggable): boolean {\n  return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n}\n\n// Get {x, y} positions from event.\nexport function getControlPosition(e: MouseTouchEvent, touchIdentifier: ?number, draggableCore: DraggableCore): ?ControlPosition {\n  const touchObj = typeof touchIdentifier === 'number' ? getTouch(e, touchIdentifier) : null;\n  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n  const node = ReactDOM.findDOMNode(draggableCore);\n  // User can provide an offsetParent if desired.\n  const offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n  return offsetXYFromParent(touchObj || e, offsetParent);\n}\n\n// Create an data object exposed by <DraggableCore>'s events\nexport function createCoreData(draggable: DraggableCore, x: number, y: number): DraggableData {\n  const state = draggable.state;\n  const isStart = !isNum(state.lastX);\n\n  if (isStart) {\n    // If this is our first move, use the x and y as last coords.\n    return {\n      node: ReactDOM.findDOMNode(draggable),\n      deltaX: 0, deltaY: 0,\n      lastX: x, lastY: y,\n      x: x, y: y\n    };\n  } else {\n    // Otherwise calculate proper values.\n    return {\n      node: ReactDOM.findDOMNode(draggable),\n      deltaX: x - state.lastX, deltaY: y - state.lastY,\n      lastX: state.lastX, lastY: state.lastY,\n      x: x, y: y\n    };\n  }\n}\n\n// Create an data exposed by <Draggable>'s events\nexport function createDraggableData(draggable: Draggable, coreData: DraggableData): DraggableData {\n  return {\n    node: coreData.node,\n    x: draggable.state.x + coreData.deltaX,\n    y: draggable.state.y + coreData.deltaY,\n    deltaX: coreData.deltaX,\n    deltaY: coreData.deltaY,\n    lastX: draggable.state.x,\n    lastY: draggable.state.y\n  };\n}\n\n// A lot faster than stringify/parse\nfunction cloneBounds(bounds: Bounds): Bounds {\n  return {\n    left: bounds.left,\n    top: bounds.top,\n    right: bounds.right,\n    bottom: bounds.bottom\n  };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/positionFns.es6","// @flow\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport ReactDOM from 'react-dom';\nimport {matchesSelectorAndParentsTo, addEvent, removeEvent, addUserSelectStyles, getTouchIdentifier,\n        removeUserSelectStyles, styleHacks} from './utils/domFns';\nimport {createCoreData, getControlPosition, snapToGrid} from './utils/positionFns';\nimport {dontSetMe} from './utils/shims';\nimport log from './utils/log';\n\nimport type {EventHandler} from './utils/types';\n\n// Simple abstraction for dragging events names.\nconst eventsFor = {\n  touch: {\n    start: 'touchstart',\n    move: 'touchmove',\n    stop: 'touchend'\n  },\n  mouse: {\n    start: 'mousedown',\n    move: 'mousemove',\n    stop: 'mouseup'\n  }\n};\n\n// Default to mouse events.\nlet dragEventFor = eventsFor.mouse;\n\ntype CoreState = {\n  dragging: boolean,\n  lastX: number,\n  lastY: number,\n  touchIdentifier: ?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//\n\nexport default class DraggableCore extends React.Component {\n\n  static displayName = 'DraggableCore';\n\n  static 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.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.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.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(props, propName) {\n      if (process.browser && props[propName] && props[propName].nodeType !== 1) {\n        throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n      }\n    },\n\n    /**\n     * `grid` specifies the x and y that dragging should snap to.\n     */\n    grid: PropTypes.arrayOf(PropTypes.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.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.string,\n\n    /**\n     * Called when dragging starts.\n     * If this function returns the boolean false, dragging will be canceled.\n     */\n    onStart: PropTypes.func,\n\n    /**\n     * Called while dragging.\n     * If this function returns the boolean false, dragging will be canceled.\n     */\n    onDrag: PropTypes.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.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.func,\n\n    /**\n     * These properties should be defined on the child, not here.\n     */\n    className: dontSetMe,\n    style: dontSetMe,\n    transform: dontSetMe\n  };\n\n  static defaultProps = {\n    allowAnyClick: false, // by default only accept left click\n    cancel: null,\n    disabled: false,\n    enableUserSelectHack: true,\n    offsetParent: null,\n    handle: null,\n    grid: null,\n    transform: null,\n    onStart: function(){},\n    onDrag: function(){},\n    onStop: function(){},\n    onMouseDown: function(){}\n  };\n\n  state: CoreState = {\n    dragging: false,\n    // Used while dragging to determine deltas.\n    lastX: NaN, lastY: NaN,\n    touchIdentifier: null\n  };\n\n  componentWillUnmount() {\n    // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n    // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n    const {ownerDocument} = ReactDOM.findDOMNode(this);\n    removeEvent(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n    removeEvent(ownerDocument, eventsFor.touch.move, this.handleDrag);\n    removeEvent(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n    removeEvent(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n    if (this.props.enableUserSelectHack) removeUserSelectStyles(ownerDocument.body);\n  }\n\n  handleDragStart: EventHandler<MouseTouchEvent> = (e) => {\n    // Make it possible to attach event handlers on top of this one.\n    this.props.onMouseDown(e);\n\n    // Only accept left-clicks.\n    if (!this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\n    // Get nodes. Be sure to grab relative document (could be iframed)\n    const domNode = ReactDOM.findDOMNode(this);\n    const {ownerDocument} = domNode;\n\n    // Short circuit if handle or cancel prop was provided and selector doesn't match.\n    if (this.props.disabled ||\n      (!(e.target instanceof ownerDocument.defaultView.Node)) ||\n      (this.props.handle && !matchesSelectorAndParentsTo(e.target, this.props.handle, domNode)) ||\n      (this.props.cancel && matchesSelectorAndParentsTo(e.target, this.props.cancel, domNode))) {\n      return;\n    }\n\n    // Set touch identifier in component state if this is a touch event. This allows us to\n    // distinguish between individual touches on multitouch screens by identifying which\n    // touchpoint was set to this element.\n    const touchIdentifier = getTouchIdentifier(e);\n    this.setState({touchIdentifier});\n\n    // Get the current drag point from the event. This is used as the offset.\n    const position = getControlPosition(e, touchIdentifier, this);\n    if (position == null) return; // not possible but satisfies flow\n    const {x, y} = position;\n\n    // Create an event object with all the data parents need to make a decision here.\n    const coreEvent = createCoreData(this, x, y);\n\n    log('DraggableCore: handleDragStart: %j', coreEvent);\n\n    // Call event handler. If it returns explicit false, cancel.\n    log('calling', this.props.onStart);\n    const shouldUpdate = this.props.onStart(e, coreEvent);\n    if (shouldUpdate === false) return;\n\n    // Add a style to the body to disable user-select. This prevents text from\n    // being selected all over the page.\n    if (this.props.enableUserSelectHack) addUserSelectStyles(ownerDocument.body);\n\n    // Initiate dragging. Set the current x and y as offsets\n    // so we know how much we've moved during the drag. This allows us\n    // to drag elements around even if they have been moved, without issue.\n    this.setState({\n      dragging: true,\n\n      lastX: x,\n      lastY: y\n    });\n\n    // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n    // this element. We use different events depending on whether or not we have detected that this\n    // is a touch-capable device.\n    addEvent(ownerDocument, dragEventFor.move, this.handleDrag);\n    addEvent(ownerDocument, dragEventFor.stop, this.handleDragStop);\n  };\n\n  handleDrag: EventHandler<MouseTouchEvent> = (e) => {\n\n    // Prevent scrolling on mobile devices, like ipad/iphone.\n    if (e.type === 'touchmove') e.preventDefault();\n\n    // Get the current drag point from the event. This is used as the offset.\n    const position = getControlPosition(e, this.state.touchIdentifier, this);\n    if (position == null) return;\n    let {x, y} = position;\n\n    // Snap to grid if prop has been provided\n    if (Array.isArray(this.props.grid)) {\n      let deltaX = x - this.state.lastX, deltaY = y - this.state.lastY;\n      [deltaX, deltaY] = snapToGrid(this.props.grid, deltaX, deltaY);\n      if (!deltaX && !deltaY) return; // skip useless drag\n      x = this.state.lastX + deltaX, y = this.state.lastY + deltaY;\n    }\n\n    const coreEvent = createCoreData(this, x, y);\n\n    log('DraggableCore: handleDrag: %j', coreEvent);\n\n    // Call event handler. If it returns explicit false, trigger end.\n    const shouldUpdate = this.props.onDrag(e, coreEvent);\n    if (shouldUpdate === false) {\n      try {\n        // $FlowIgnore\n        this.handleDragStop(new MouseEvent('mouseup'));\n      } catch (err) {\n        // Old browsers\n        const event = ((document.createEvent('MouseEvents'): any): MouseTouchEvent);\n        // I see why this insanity was deprecated\n        // $FlowIgnore\n        event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n        this.handleDragStop(event);\n      }\n      return;\n    }\n\n    this.setState({\n      lastX: x,\n      lastY: y\n    });\n  };\n\n  handleDragStop: EventHandler<MouseTouchEvent> = (e) => {\n    if (!this.state.dragging) return;\n\n    const position = getControlPosition(e, this.state.touchIdentifier, this);\n    if (position == null) return;\n    const {x, y} = position;\n    const coreEvent = createCoreData(this, x, y);\n    const {ownerDocument} = ReactDOM.findDOMNode(this);\n\n    // Remove user-select hack\n    if (this.props.enableUserSelectHack) removeUserSelectStyles(ownerDocument.body);\n\n    log('DraggableCore: handleDragStop: %j', coreEvent);\n\n    // Reset the el.\n    this.setState({\n      dragging: false,\n      lastX: NaN,\n      lastY: NaN\n    });\n\n    // Call event handler\n    this.props.onStop(e, coreEvent);\n\n    // Remove event handlers\n    log('DraggableCore: Removing handlers');\n    removeEvent(ownerDocument, dragEventFor.move, this.handleDrag);\n    removeEvent(ownerDocument, dragEventFor.stop, this.handleDragStop);\n  };\n\n  onMouseDown: EventHandler<MouseTouchEvent> = (e) => {\n    dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n    return this.handleDragStart(e);\n  };\n\n  onMouseUp: EventHandler<MouseTouchEvent> = (e) => {\n    dragEventFor = eventsFor.mouse;\n\n    return this.handleDragStop(e);\n  };\n\n  // Same as onMouseDown (start drag), but now consider this a touch device.\n  onTouchStart: EventHandler<MouseTouchEvent> = (e) => {\n    // We're on a touch device now, so change the event handlers\n    dragEventFor = eventsFor.touch;\n\n    return this.handleDragStart(e);\n  };\n\n  onTouchEnd: EventHandler<MouseTouchEvent> = (e) => {\n    // We're on a touch device now, so change the event handlers\n    dragEventFor = eventsFor.touch;\n\n    return this.handleDragStop(e);\n  };\n\n  render(): React.Element<any> {\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      style: styleHacks(this.props.children.props.style),\n\n      // Note: mouseMove handler is attached to document so it will still function\n      // when the user drags quickly and leaves the bounds of the element.\n      onMouseDown: this.onMouseDown,\n      onTouchStart: this.onTouchStart,\n      onMouseUp: this.onMouseUp,\n      onTouchEnd: this.onTouchEnd\n    });\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/DraggableCore.es6","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process/browser.js\n// module id = 18\n// module chunks = 0","// @flow\n/*eslint no-console:0*/\nexport default function log(...args: any) {\n  if (process.env.DRAGGABLE_DEBUG) console.log(...args);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/log.es6"],"sourceRoot":""}