{"ast":null,"code":"'use strict';\n\nimport InteractionManager from \"../../../exports/InteractionManager\";\nimport TouchHistoryMath from \"../TouchHistoryMath\";\nvar currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;\nvar currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;\nvar previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;\nvar previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;\nvar currentCentroidX = TouchHistoryMath.currentCentroidX;\nvar currentCentroidY = TouchHistoryMath.currentCentroidY;\nvar PanResponder = {\n  _initializeGestureState: function _initializeGestureState(gestureState) {\n    gestureState.moveX = 0;\n    gestureState.moveY = 0;\n    gestureState.x0 = 0;\n    gestureState.y0 = 0;\n    gestureState.dx = 0;\n    gestureState.dy = 0;\n    gestureState.vx = 0;\n    gestureState.vy = 0;\n    gestureState.numberActiveTouches = 0;\n    gestureState._accountsForMovesUpTo = 0;\n  },\n  _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {\n    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n    var movedAfter = gestureState._accountsForMovesUpTo;\n    var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    var nextDX = gestureState.dx + (x - prevX);\n    var nextDY = gestureState.dy + (y - prevY);\n    var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;\n    gestureState.vx = (nextDX - gestureState.dx) / dt;\n    gestureState.vy = (nextDY - gestureState.dy) / dt;\n    gestureState.dx = nextDX;\n    gestureState.dy = nextDY;\n    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;\n  },\n  create: function create(config) {\n    var interactionState = {\n      handle: null,\n      shouldCancelClick: false,\n      timeout: null\n    };\n    var gestureState = {\n      stateID: Math.random(),\n      moveX: 0,\n      moveY: 0,\n      x0: 0,\n      y0: 0,\n      dx: 0,\n      dy: 0,\n      vx: 0,\n      vy: 0,\n      numberActiveTouches: 0,\n      _accountsForMovesUpTo: 0\n    };\n    var panHandlers = {\n      onStartShouldSetResponder: function onStartShouldSetResponder(event) {\n        return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);\n      },\n      onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {\n        return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);\n      },\n      onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {\n        if (event.nativeEvent.touches.length === 1) {\n          PanResponder._initializeGestureState(gestureState);\n        }\n\n        gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;\n        return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;\n      },\n      onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {\n        var touchHistory = event.touchHistory;\n\n        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n          return false;\n        }\n\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n\n        return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;\n      },\n      onResponderGrant: function onResponderGrant(event) {\n        if (!interactionState.handle) {\n          interactionState.handle = InteractionManager.createInteractionHandle();\n        }\n\n        if (interactionState.timeout) {\n          clearInteractionTimeout(interactionState);\n        }\n\n        interactionState.shouldCancelClick = true;\n        gestureState.x0 = currentCentroidX(event.touchHistory);\n        gestureState.y0 = currentCentroidY(event.touchHistory);\n        gestureState.dx = 0;\n        gestureState.dy = 0;\n\n        if (config.onPanResponderGrant) {\n          config.onPanResponderGrant(event, gestureState);\n        }\n\n        return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);\n      },\n      onResponderReject: function onResponderReject(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);\n      },\n      onResponderRelease: function onResponderRelease(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);\n        setInteractionTimeout(interactionState);\n\n        PanResponder._initializeGestureState(gestureState);\n      },\n      onResponderStart: function onResponderStart(event) {\n        var touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n\n        if (config.onPanResponderStart) {\n          config.onPanResponderStart(event, gestureState);\n        }\n      },\n      onResponderMove: function onResponderMove(event) {\n        var touchHistory = event.touchHistory;\n\n        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n          return;\n        }\n\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n\n        if (config.onPanResponderMove) {\n          config.onPanResponderMove(event, gestureState);\n        }\n      },\n      onResponderEnd: function onResponderEnd(event) {\n        var touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);\n      },\n      onResponderTerminate: function onResponderTerminate(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);\n        setInteractionTimeout(interactionState);\n\n        PanResponder._initializeGestureState(gestureState);\n      },\n      onResponderTerminationRequest: function onResponderTerminationRequest(event) {\n        return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);\n      },\n      onClickCapture: function onClickCapture(event) {\n        if (interactionState.shouldCancelClick === true) {\n          event.stopPropagation();\n          event.preventDefault();\n        }\n      }\n    };\n    return {\n      panHandlers: panHandlers,\n      getInteractionHandle: function getInteractionHandle() {\n        return interactionState.handle;\n      }\n    };\n  }\n};\n\nfunction clearInteractionHandle(interactionState, callback, event, gestureState) {\n  if (interactionState.handle) {\n    InteractionManager.clearInteractionHandle(interactionState.handle);\n    interactionState.handle = null;\n  }\n\n  if (callback) {\n    callback(event, gestureState);\n  }\n}\n\nfunction clearInteractionTimeout(interactionState) {\n  clearTimeout(interactionState.timeout);\n}\n\nfunction setInteractionTimeout(interactionState) {\n  interactionState.timeout = setTimeout(function () {\n    interactionState.shouldCancelClick = false;\n  }, 250);\n}\n\nexport default PanResponder;","map":{"version":3,"sources":["/Users/rohitsingh/Documents/projects/new-nativebase-setup/NativeBase/example/node_modules/react-native-web/dist/vendor/react-native/PanResponder/index.js"],"names":["InteractionManager","TouchHistoryMath","currentCentroidXOfTouchesChangedAfter","currentCentroidYOfTouchesChangedAfter","previousCentroidXOfTouchesChangedAfter","previousCentroidYOfTouchesChangedAfter","currentCentroidX","currentCentroidY","PanResponder","_initializeGestureState","gestureState","moveX","moveY","x0","y0","dx","dy","vx","vy","numberActiveTouches","_accountsForMovesUpTo","_updateGestureStateOnMove","touchHistory","movedAfter","prevX","x","prevY","y","nextDX","nextDY","dt","mostRecentTimeStamp","create","config","interactionState","handle","shouldCancelClick","timeout","stateID","Math","random","panHandlers","onStartShouldSetResponder","event","onStartShouldSetPanResponder","onMoveShouldSetResponder","onMoveShouldSetPanResponder","onStartShouldSetResponderCapture","nativeEvent","touches","length","onStartShouldSetPanResponderCapture","onMoveShouldSetResponderCapture","onMoveShouldSetPanResponderCapture","onResponderGrant","createInteractionHandle","clearInteractionTimeout","onPanResponderGrant","onShouldBlockNativeResponder","onResponderReject","clearInteractionHandle","onPanResponderReject","onResponderRelease","onPanResponderRelease","setInteractionTimeout","onResponderStart","onPanResponderStart","onResponderMove","onPanResponderMove","onResponderEnd","onPanResponderEnd","onResponderTerminate","onPanResponderTerminate","onResponderTerminationRequest","onPanResponderTerminationRequest","onClickCapture","stopPropagation","preventDefault","getInteractionHandle","callback","clearTimeout","setTimeout"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n'use strict';\n\nimport InteractionManager from '../../../exports/InteractionManager';\nimport TouchHistoryMath from '../TouchHistoryMath';\nvar currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;\nvar currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;\nvar previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;\nvar previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;\nvar currentCentroidX = TouchHistoryMath.currentCentroidX;\nvar currentCentroidY = TouchHistoryMath.currentCentroidY;\n/**\n * `PanResponder` reconciles several touches into a single gesture. It makes\n * single-touch gestures resilient to extra touches, and can be used to\n * recognize simple multi-touch gestures.\n *\n * By default, `PanResponder` holds an `InteractionManager` handle to block\n * long-running JS events from interrupting active gestures.\n *\n * It provides a predictable wrapper of the responder handlers provided by the\n * [gesture responder system](docs/gesture-responder-system.html).\n * For each handler, it provides a new `gestureState` object alongside the\n * native event object:\n *\n * ```\n * onPanResponderMove: (event, gestureState) => {}\n * ```\n *\n * A native event is a synthetic touch event with the following form:\n *\n *  - `nativeEvent`\n *      + `changedTouches` - Array of all touch events that have changed since the last event\n *      + `identifier` - The ID of the touch\n *      + `locationX` - The X position of the touch, relative to the element\n *      + `locationY` - The Y position of the touch, relative to the element\n *      + `pageX` - The X position of the touch, relative to the root element\n *      + `pageY` - The Y position of the touch, relative to the root element\n *      + `target` - The node id of the element receiving the touch event\n *      + `timestamp` - A time identifier for the touch, useful for velocity calculation\n *      + `touches` - Array of all current touches on the screen\n *\n * A `gestureState` object has the following:\n *\n *  - `stateID` - ID of the gestureState- persisted as long as there at least\n *     one touch on screen\n *  - `moveX` - the latest screen coordinates of the recently-moved touch\n *  - `moveY` - the latest screen coordinates of the recently-moved touch\n *  - `x0` - the screen coordinates of the responder grant\n *  - `y0` - the screen coordinates of the responder grant\n *  - `dx` - accumulated distance of the gesture since the touch started\n *  - `dy` - accumulated distance of the gesture since the touch started\n *  - `vx` - current velocity of the gesture\n *  - `vy` - current velocity of the gesture\n *  - `numberActiveTouches` - Number of touches currently on screen\n *\n * ### Basic Usage\n *\n * ```\n *   componentWillMount: function() {\n *     this._panResponder = PanResponder.create({\n *       // Ask to be the responder:\n *       onStartShouldSetPanResponder: (evt, gestureState) => true,\n *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponder: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,\n *\n *       onPanResponderGrant: (evt, gestureState) => {\n *         // The gesture has started. Show visual feedback so the user knows\n *         // what is happening!\n *\n *         // gestureState.d{x,y} will be set to zero now\n *       },\n *       onPanResponderMove: (evt, gestureState) => {\n *         // The most recent move distance is gestureState.move{X,Y}\n *\n *         // The accumulated gesture distance since becoming responder is\n *         // gestureState.d{x,y}\n *       },\n *       onPanResponderTerminationRequest: (evt, gestureState) => true,\n *       onPanResponderRelease: (evt, gestureState) => {\n *         // The user has released all touches while this view is the\n *         // responder. This typically means a gesture has succeeded\n *       },\n *       onPanResponderTerminate: (evt, gestureState) => {\n *         // Another component has become the responder, so this gesture\n *         // should be cancelled\n *       },\n *       onShouldBlockNativeResponder: (evt, gestureState) => {\n *         // Returns whether this component should block native components from becoming the JS\n *         // responder. Returns true by default. Is currently only supported on android.\n *         return true;\n *       },\n *     });\n *   },\n *\n *   render: function() {\n *     return (\n *       <View {...this._panResponder.panHandlers} />\n *     );\n *   },\n *\n * ```\n *\n * ### Working Example\n *\n * To see it in action, try the\n * [PanResponder example in RNTester](https://github.com/facebook/react-native/blob/master/RNTester/js/PanResponderExample.js)\n */\n\nvar PanResponder = {\n  /**\n   *\n   * A graphical explanation of the touch data flow:\n   *\n   * +----------------------------+             +--------------------------------+\n   * | ResponderTouchHistoryStore |             |TouchHistoryMath                |\n   * +----------------------------+             +----------+---------------------+\n   * |Global store of touchHistory|             |Allocation-less math util       |\n   * |including activeness, start |             |on touch history (centroids     |\n   * |position, prev/cur position.|             |and multitouch movement etc)    |\n   * |                            |             |                                |\n   * +----^-----------------------+             +----^---------------------------+\n   *      |                                          |\n   *      | (records relevant history                |\n   *      |  of touches relevant for                 |\n   *      |  implementing higher level               |\n   *      |  gestures)                               |\n   *      |                                          |\n   * +----+-----------------------+             +----|---------------------------+\n   * | ResponderEventPlugin       |             |    |   Your App/Component      |\n   * +----------------------------+             +----|---------------------------+\n   * |Negotiates which view gets  | Low level   |    |             High level    |\n   * |onResponderMove events.     | events w/   |  +-+-------+     events w/     |\n   * |Also records history into   | touchHistory|  |   Pan   |     multitouch +  |\n   * |ResponderTouchHistoryStore. +---------------->Responder+-----> accumulative|\n   * +----------------------------+ attached to |  |         |     distance and  |\n   *                                 each event |  +---------+     velocity.     |\n   *                                            |                                |\n   *                                            |                                |\n   *                                            +--------------------------------+\n   *\n   *\n   *\n   * Gesture that calculates cumulative movement over time in a way that just\n   * \"does the right thing\" for multiple touches. The \"right thing\" is very\n   * nuanced. When moving two touches in opposite directions, the cumulative\n   * distance is zero in each dimension. When two touches move in parallel five\n   * pixels in the same direction, the cumulative distance is five, not ten. If\n   * two touches start, one moves five in a direction, then stops and the other\n   * touch moves fives in the same direction, the cumulative distance is ten.\n   *\n   * This logic requires a kind of processing of time \"clusters\" of touch events\n   * so that two touch moves that essentially occur in parallel but move every\n   * other frame respectively, are considered part of the same movement.\n   *\n   * Explanation of some of the non-obvious fields:\n   *\n   * - moveX/moveY: If no move event has been observed, then `(moveX, moveY)` is\n   *   invalid. If a move event has been observed, `(moveX, moveY)` is the\n   *   centroid of the most recently moved \"cluster\" of active touches.\n   *   (Currently all move have the same timeStamp, but later we should add some\n   *   threshold for what is considered to be \"moving\"). If a palm is\n   *   accidentally counted as a touch, but a finger is moving greatly, the palm\n   *   will move slightly, but we only want to count the single moving touch.\n   * - x0/y0: Centroid location (non-cumulative) at the time of becoming\n   *   responder.\n   * - dx/dy: Cumulative touch distance - not the same thing as sum of each touch\n   *   distance. Accounts for touch moves that are clustered together in time,\n   *   moving the same direction. Only valid when currently responder (otherwise,\n   *   it only represents the drag distance below the threshold).\n   * - vx/vy: Velocity.\n   */\n  _initializeGestureState: function _initializeGestureState(gestureState) {\n    gestureState.moveX = 0;\n    gestureState.moveY = 0;\n    gestureState.x0 = 0;\n    gestureState.y0 = 0;\n    gestureState.dx = 0;\n    gestureState.dy = 0;\n    gestureState.vx = 0;\n    gestureState.vy = 0;\n    gestureState.numberActiveTouches = 0; // All `gestureState` accounts for timeStamps up until:\n\n    gestureState._accountsForMovesUpTo = 0;\n  },\n\n  /**\n   * This is nuanced and is necessary. It is incorrect to continuously take all\n   * active *and* recently moved touches, find the centroid, and track how that\n   * result changes over time. Instead, we must take all recently moved\n   * touches, and calculate how the centroid has changed just for those\n   * recently moved touches, and append that change to an accumulator. This is\n   * to (at least) handle the case where the user is moving three fingers, and\n   * then one of the fingers stops but the other two continue.\n   *\n   * This is very different than taking all of the recently moved touches and\n   * storing their centroid as `dx/dy`. For correctness, we must *accumulate\n   * changes* in the centroid of recently moved touches.\n   *\n   * There is also some nuance with how we handle multiple moved touches in a\n   * single event. With the way `ReactNativeEventEmitter` dispatches touches as\n   * individual events, multiple touches generate two 'move' events, each of\n   * them triggering `onResponderMove`. But with the way `PanResponder` works,\n   * all of the gesture inference is performed on the first dispatch, since it\n   * looks at all of the touches (even the ones for which there hasn't been a\n   * native dispatch yet). Therefore, `PanResponder` does not call\n   * `onResponderMove` passed the first dispatch. This diverges from the\n   * typical responder callback pattern (without using `PanResponder`), but\n   * avoids more dispatches than necessary.\n   */\n  _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {\n    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n    var movedAfter = gestureState._accountsForMovesUpTo;\n    var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    var nextDX = gestureState.dx + (x - prevX);\n    var nextDY = gestureState.dy + (y - prevY); // TODO: This must be filtered intelligently.\n\n    var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;\n    gestureState.vx = (nextDX - gestureState.dx) / dt;\n    gestureState.vy = (nextDY - gestureState.dy) / dt;\n    gestureState.dx = nextDX;\n    gestureState.dy = nextDY;\n    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;\n  },\n\n  /**\n   * @param {object} config Enhanced versions of all of the responder callbacks\n   * that provide not only the typical `ResponderSyntheticEvent`, but also the\n   * `PanResponder` gesture state.  Simply replace the word `Responder` with\n   * `PanResponder` in each of the typical `onResponder*` callbacks. For\n   * example, the `config` object would look like:\n   *\n   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onPanResponderReject: (e, gestureState) => {...}`\n   *  - `onPanResponderGrant: (e, gestureState) => {...}`\n   *  - `onPanResponderStart: (e, gestureState) => {...}`\n   *  - `onPanResponderEnd: (e, gestureState) => {...}`\n   *  - `onPanResponderRelease: (e, gestureState) => {...}`\n   *  - `onPanResponderMove: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminate: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`\n   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`\n   *\n   *  In general, for events that have capture equivalents, we update the\n   *  gestureState once in the capture phase and can use it in the bubble phase\n   *  as well.\n   *\n   *  Be careful with onStartShould* callbacks. They only reflect updated\n   *  `gestureState` for start/end events that bubble/capture to the Node.\n   *  Once the node is the responder, you can rely on every start/end event\n   *  being processed by the gesture and `gestureState` being updated\n   *  accordingly. (numberActiveTouches) may not be totally accurate unless you\n   *  are the responder.\n   */\n  create: function create(config) {\n    var interactionState = {\n      handle: null,\n      shouldCancelClick: false,\n      timeout: null\n    };\n    var gestureState = {\n      // Useful for debugging\n      stateID: Math.random(),\n      moveX: 0,\n      moveY: 0,\n      x0: 0,\n      y0: 0,\n      dx: 0,\n      dy: 0,\n      vx: 0,\n      vy: 0,\n      numberActiveTouches: 0,\n      _accountsForMovesUpTo: 0\n    };\n    var panHandlers = {\n      onStartShouldSetResponder: function onStartShouldSetResponder(event) {\n        return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);\n      },\n      onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {\n        return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);\n      },\n      onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {\n        // TODO: Actually, we should reinitialize the state any time\n        // touches.length increases from 0 active to > 0 active.\n        if (event.nativeEvent.touches.length === 1) {\n          PanResponder._initializeGestureState(gestureState);\n        }\n\n        gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;\n        return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;\n      },\n      onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {\n        var touchHistory = event.touchHistory; // Responder system incorrectly dispatches should* to current responder\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n\n        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n          return false;\n        }\n\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n\n        return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;\n      },\n      onResponderGrant: function onResponderGrant(event) {\n        if (!interactionState.handle) {\n          interactionState.handle = InteractionManager.createInteractionHandle();\n        }\n\n        if (interactionState.timeout) {\n          clearInteractionTimeout(interactionState);\n        }\n\n        interactionState.shouldCancelClick = true;\n        gestureState.x0 = currentCentroidX(event.touchHistory);\n        gestureState.y0 = currentCentroidY(event.touchHistory);\n        gestureState.dx = 0;\n        gestureState.dy = 0;\n\n        if (config.onPanResponderGrant) {\n          config.onPanResponderGrant(event, gestureState);\n        } // TODO: t7467124 investigate if this can be removed\n\n\n        return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);\n      },\n      onResponderReject: function onResponderReject(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);\n      },\n      onResponderRelease: function onResponderRelease(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);\n        setInteractionTimeout(interactionState);\n\n        PanResponder._initializeGestureState(gestureState);\n      },\n      onResponderStart: function onResponderStart(event) {\n        var touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n\n        if (config.onPanResponderStart) {\n          config.onPanResponderStart(event, gestureState);\n        }\n      },\n      onResponderMove: function onResponderMove(event) {\n        var touchHistory = event.touchHistory; // Guard against the dispatch of two touch moves when there are two\n        // simultaneously changed touches.\n\n        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n          return;\n        } // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n\n\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n\n        if (config.onPanResponderMove) {\n          config.onPanResponderMove(event, gestureState);\n        }\n      },\n      onResponderEnd: function onResponderEnd(event) {\n        var touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);\n      },\n      onResponderTerminate: function onResponderTerminate(event) {\n        clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);\n        setInteractionTimeout(interactionState);\n\n        PanResponder._initializeGestureState(gestureState);\n      },\n      onResponderTerminationRequest: function onResponderTerminationRequest(event) {\n        return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);\n      },\n      // We do not want to trigger 'click' activated gestures or native behaviors\n      // on any pan target that is under a mouse cursor when it is released.\n      // Browsers will natively cancel 'click' events on a target if a non-mouse\n      // active pointer moves.\n      onClickCapture: function onClickCapture(event) {\n        if (interactionState.shouldCancelClick === true) {\n          event.stopPropagation();\n          event.preventDefault();\n        }\n      }\n    };\n    return {\n      panHandlers: panHandlers,\n      getInteractionHandle: function getInteractionHandle() {\n        return interactionState.handle;\n      }\n    };\n  }\n};\n\nfunction clearInteractionHandle(interactionState, callback, event, gestureState) {\n  if (interactionState.handle) {\n    InteractionManager.clearInteractionHandle(interactionState.handle);\n    interactionState.handle = null;\n  }\n\n  if (callback) {\n    callback(event, gestureState);\n  }\n}\n\nfunction clearInteractionTimeout(interactionState) {\n  clearTimeout(interactionState.timeout);\n}\n\nfunction setInteractionTimeout(interactionState) {\n  interactionState.timeout = setTimeout(function () {\n    interactionState.shouldCancelClick = false;\n  }, 250);\n}\n\nexport default PanResponder;"]},"metadata":{},"sourceType":"module"}