/** @license React v16.13.

1
* react-dom-unstable-native-dependencies.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/

'use strict';

(function (global, factory) {

typeof exports === 'object' && typeof module !== 'undefined' ? module.exports =
factory(require('react-dom'), require('react')) :
typeof define === 'function' && define.amd ? define(['react-dom', 'react'],
factory) :
(global = global || self, global.ReactDOMUnstableNativeDependencies =
factory(global.ReactDOM, global.React));
}(this, (function (ReactDOM, React) { 'use strict';

var ReactSharedInternals =
React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; // Prevent newer
renderers from RTE when used with older react package versions.
// Current owner and dispatcher used to share the same ref,
// but PR #14548 split them out to better support the react-debug-tools package.

if (!ReactSharedInternals.hasOwnProperty('ReactCurrentDispatcher')) {
ReactSharedInternals.ReactCurrentDispatcher = {
current: null
};
}

if (!ReactSharedInternals.hasOwnProperty('ReactCurrentBatchConfig')) {
ReactSharedInternals.ReactCurrentBatchConfig = {
suspense: null
};
}

// by calls to these methods by a Babel plugin.

//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.

function warn(format) {
{
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0),
_key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}

printWarning('warn', format, args);

}
}
function error(format) {
{
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 :
0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
 printWarning('error', format, args);
}
}

function printWarning(level, format, args) {

// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{
var hasExistingStack = args.length > 0 && typeof args[args.length - 1] ===
'string' && args[args.length - 1].indexOf('\n in') === 0;

if (!hasExistingStack) {
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame.getStackAddendum();

if (stack !== '') {

format += '%s';
args = args.concat([stack]);
}
}

var argsWithFormat = args.map(function (item) {

return '' + item;
}); // Careful: RN currently depends on this prefix

argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use

spread (or .apply) directly because it
// breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging

Function.prototype.apply.call(console[level], console, argsWithFormat);

try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
var argIndex = 0;
var message = 'Warning: ' + format.replace(/%s/g, function () {
return args[argIndex++];
});
throw new Error(message);
} catch (x) {}
}
}

{
// In DEV mode, we swap out invokeGuardedCallback for a special version
// that plays more nicely with the browser's DevTools. The idea is to preserve
// "Pause on exceptions" behavior. Because React wraps all user-provided
// functions in invokeGuardedCallback, and the production version of
// invokeGuardedCallback uses a try-catch, all user exceptions are treated
// like caught exceptions, and the DevTools won't pause unless the developer
// takes the extra step of enabling pause on caught exceptions. This is
// unintuitive, though, because even though React has caught the error, from
// the developer's perspective, the error is uncaught.
//
// To preserve the expected "Pause on exceptions" behavior, we don't use a
// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake
 // DOM node, and call the user-provided callback from inside an event handler
// for that fake event. If the callback throws, the error is "captured" using
// a global event handler. But because the error happens in a different
// event loop context, it does not interrupt the normal program flow.
// Effectively, this gives us try-catch behavior without actually using
// try-catch. Neat!
// Check that the browser supports the APIs we need to implement our special
// DEV version of invokeGuardedCallback
if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function'
&& typeof document !== 'undefined' && typeof document.createEvent === 'function') {
var fakeNode = document.createElement('react');
}
}

var getFiberCurrentPropsFromNode = null;

var getInstanceFromNode = null;
var getNodeFromInstance = null;
function setComponentTree(getFiberCurrentPropsFromNodeImpl,
getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
getInstanceFromNode = getInstanceFromNodeImpl;
getNodeFromInstance = getNodeFromInstanceImpl;

{
if (!getNodeFromInstance || !getInstanceFromNode) {
error('EventPluginUtils.setComponentTree(...): Injected ' + 'module is
missing getNodeFromInstance or getInstanceFromNode.');
}
}
}
var validateEventDispatches;

{
validateEventDispatches = function (event) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
var listenersIsArr = Array.isArray(dispatchListeners);
var listenersLen = listenersIsArr ? dispatchListeners.length :
dispatchListeners ? 1 : 0;
var instancesIsArr = Array.isArray(dispatchInstances);
var instancesLen = instancesIsArr ? dispatchInstances.length :
dispatchInstances ? 1 : 0;

if (instancesIsArr !== listenersIsArr || instancesLen !== listenersLen) {

error('EventPluginUtils: Invalid `event`.');
}
};
}
/**
* Standard/simple iteration through an event's collected dispatches, but stops
* at the first dispatch execution returning true, and returns that id.
*
* @return {?string} id of the first dispatch execution who's listener returns
* true, or null if no listener returned true.
*/

function executeDispatchesInOrderStopAtTrueImpl(event) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
 {
validateEventDispatches(event);
}

if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
} // Listeners and Instances are two parallel arrays that are always in
sync.

if (dispatchListeners[i](event, dispatchInstances[i])) {
return dispatchInstances[i];
}
}
} else if (dispatchListeners) {
if (dispatchListeners(event, dispatchInstances)) {
return dispatchInstances;
}
}

return null;
}
/**
* @see executeDispatchesInOrderStopAtTrueImpl
*/

function executeDispatchesInOrderStopAtTrue(event) {
var ret = executeDispatchesInOrderStopAtTrueImpl(event);
event._dispatchInstances = null;
event._dispatchListeners = null;
return ret;
}
/**
* Execution of a "direct" dispatch - there must be at most one dispatch
* accumulated on the event or it is considered an error. It doesn't really make
* sense for an event with multiple dispatches (bubbled) to keep track of the
* return values at each dispatch execution, but it does tend to make sense when
* dealing with "direct" dispatches.
*
* @return {*} The return value of executing the single dispatch.
*/

function executeDirectDispatch(event) {
{
validateEventDispatches(event);
}

var dispatchListener = event._dispatchListeners;

var dispatchInstance = event._dispatchInstances;

if (!!Array.isArray(dispatchListener)) {
{
throw Error( "executeDirectDispatch(...): Invalid `event`." );
}
}
 event.currentTarget = dispatchListener ?
getNodeFromInstance(dispatchInstance) : null;
var res = dispatchListener ? dispatchListener(event) : null;
event.currentTarget = null;
event._dispatchListeners = null;
event._dispatchInstances = null;
return res;
}
/**
* @param {SyntheticEvent} event
* @return {boolean} True iff number of dispatches accumulated is greater than 0.
*/

function hasDispatches(event) {
return !!event._dispatchListeners;
}

var HostComponent = 5;

function getParent(inst) {
do {
inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
// That is depending on if we want nested subtrees (layers) to bubble
// events to their parent. We could also go through parentNode on the
// host node but that wouldn't work for React Native and doesn't let us
// do the portal feature.
} while (inst && inst.tag !== HostComponent);

if (inst) {
return inst;
}

return null;
}
/**
* Return the lowest common ancestor of A and B, or null if they are in
* different trees.
*/

function getLowestCommonAncestor(instA, instB) {

var depthA = 0;

for (var tempA = instA; tempA; tempA = getParent(tempA)) {

depthA++;
}

var depthB = 0;

for (var tempB = instB; tempB; tempB = getParent(tempB)) {

depthB++;
} // If A is deeper, crawl up.

while (depthA - depthB > 0) {

instA = getParent(instA);
depthA--;
} // If B is deeper, crawl up.
 while (depthB - depthA > 0) {
instB = getParent(instB);
depthB--;
} // Walk in lockstep until we find a match.

var depth = depthA;

while (depth--) {
if (instA === instB || instA === instB.alternate) {
return instA;
}

instA = getParent(instA);
instB = getParent(instB);
}

return null;
}
/**
* Return if A is an ancestor of B.
*/

function isAncestor(instA, instB) {

while (instB) {
if (instA === instB || instA === instB.alternate) {
return true;
}

instB = getParent(instB);
}

return false;
}
/**
* Return the parent instance of the passed-in instance.
*/

function getParentInstance(inst) {
return getParent(inst);
}
/**
* Simulates the traversal of a two-phase, capture/bubble event dispatch.
*/

function traverseTwoPhase(inst, fn, arg) {

var path = [];

while (inst) {
path.push(inst);
inst = getParent(inst);
}

var i;

for (i = path.length; i-- > 0;) {

fn(path[i], 'captured', arg);
 }

for (i = 0; i < path.length; i++) {

fn(path[i], 'bubbled', arg);
}
}

function isInteractive(tag) {
return tag === 'button' || tag === 'input' || tag === 'select' || tag ===
'textarea';
}

function shouldPreventMouseEvent(name, type, props) {

switch (name) {
case 'onClick':
case 'onClickCapture':
case 'onDoubleClick':
case 'onDoubleClickCapture':
case 'onMouseDown':
case 'onMouseDownCapture':
case 'onMouseMove':
case 'onMouseMoveCapture':
case 'onMouseUp':
case 'onMouseUpCapture':
case 'onMouseEnter':
return !!(props.disabled && isInteractive(type));

default:
return false;
}
}
/**
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @return {?function} The stored callback.
*/

function getListener(inst, registrationName) {

var listener; // TODO: shouldPreventMouseEvent is DOM-specific and definitely
should not
// live here; needs to be moved to a better place soon

var stateNode = inst.stateNode;

if (!stateNode) {
// Work in progress (ex: onload events in incremental mode).
return null;
}

var props = getFiberCurrentPropsFromNode(stateNode);

if (!props) {
// Work in progress.
return null;
}

listener = props[registrationName];
 if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
return null;
}

if (!(!listener || typeof listener === 'function')) {

{
throw Error( "Expected `" + registrationName + "` listener to be a
function, instead got a value of `" + typeof listener + "` type." );
}
}

return listener;
}

/**
* Accumulates items that must not be null or undefined into the first one. This
* is used to conserve memory by avoiding array allocations, and thus sacrifices
* API cleanness. Since `current` can be null before being passed in and not
* null after this function, make sure to assign it back to `current`:
*
* `a = accumulateInto(a, b);`
*
* This API should be sparingly used. Try `accumulate` for something cleaner.
*
* @return {*|array<*>} An accumulation of items.
*/

function accumulateInto(current, next) {

if (!(next != null)) {
{
throw Error( "accumulateInto(...): Accumulated items must not be null or
undefined." );
}
}

if (current == null) {
return next;
} // Both are not empty. Warning: Never call x.concat(y) when you are not
// certain that x is an Array (x could be a string with concat method).

if (Array.isArray(current)) {
if (Array.isArray(next)) {
current.push.apply(current, next);
return current;
}

current.push(next);
return current;
}

if (Array.isArray(next)) {
// A bit too dangerous to mutate `next`.
return [current].concat(next);
}

return [current, next];

}
 /**
* @param {array} arr an "accumulation" of items which is either an Array or
* a single item. Useful when paired with the `accumulate` module. This is a
* simple utility that allows us to reason about a collection of items, but
* handling the case when there is exactly one item (and we do not need to
* allocate an array).
* @param {function} cb Callback invoked with each element or a collection.
* @param {?} [scope] Scope used as `this` in a callback.
*/
function forEachAccumulated(arr, cb, scope) {
if (Array.isArray(arr)) {
arr.forEach(cb, scope);
} else if (arr) {
cb.call(scope, arr);
}
}

/**
* Some event types have a notion of different registration names for different
* "phases" of propagation. This finds listeners by a given phase.
*/
function listenerAtPhase(inst, event, propagationPhase) {
var registrationName =
event.dispatchConfig.phasedRegistrationNames[propagationPhase];
return getListener(inst, registrationName);
}
/**
* A small set of propagation patterns, each of which will accept a small amount
* of information, and generate a set of "dispatch ready event objects" - which
* are sets of events that have already been annotated with a set of dispatched
* listener functions/ids. The API is designed this way to discourage these
* propagation strategies from actually executing the dispatches, since we
* always want to collect the entire set of dispatches before executing even a
* single one.
*/

/**
* Tags a `SyntheticEvent` with dispatched listeners. Creating this function
* here, allows us to not have to bind or create functions for each event.
* Mutating the event's members allows us to not have to create a wrapping
* "dispatch" object that pairs the event with the listener.
*/

function accumulateDirectionalDispatches(inst, phase, event) {

{
if (!inst) {
error('Dispatching inst must not be null');
}
}

var listener = listenerAtPhase(inst, event, phase);

if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners,
listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
 /**
* Collect dispatches (must be entirely collected before dispatching - see unit
* tests). Lazily allocate the array to conserve memory. We must loop through
* each event and perform the traversal for each one. We cannot perform a
* single traversal for the entire collection of events because each event may
* have a different target.
*/

function accumulateTwoPhaseDispatchesSingle(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
}
}
/**
* Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
*/

function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
var targetInst = event._targetInst;
var parentInst = targetInst ? getParentInstance(targetInst) : null;
traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
}
}
/**
* Accumulates without regard to direction, does not look for phased
* registration names. Same as `accumulateDirectDispatchesSingle` but without
* requiring that the `dispatchMarker` be the same as the dispatched ID.
*/

function accumulateDispatches(inst, ignoredDirection, event) {

if (inst && event && event.dispatchConfig.registrationName) {
var registrationName = event.dispatchConfig.registrationName;
var listener = getListener(inst, registrationName);

if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners,
listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
}
/**
* Accumulates dispatches on an `SyntheticEvent`, but only for the
* `dispatchMarker`.
* @param {SyntheticEvent} event
*/

function accumulateDirectDispatchesSingle(event) {
if (event && event.dispatchConfig.registrationName) {
accumulateDispatches(event._targetInst, null, event);
}
}

function accumulateTwoPhaseDispatches(events) {
 forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
}
function accumulateTwoPhaseDispatchesSkipTarget(events) {
forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
}
function accumulateDirectDispatches(events) {
forEachAccumulated(events, accumulateDirectDispatchesSingle);
}

var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

var _assign = ReactInternals.assign;

var EVENT_POOL_SIZE = 10;

/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/

var EventInterface = {
type: null,
target: null,
// currentTarget is set when dispatching; no use in copying it here
currentTarget: function () {
return null;
},
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};

function functionThatReturnsTrue() {
return true;
}

function functionThatReturnsFalse() {
return false;
}
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {*} targetInst Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @param {DOMEventTarget} nativeEventTarget Target node.
 */

function SyntheticEvent(dispatchConfig, targetInst, nativeEvent,

nativeEventTarget) {
{
// these have a getter/setter for warnings
delete this.nativeEvent;
delete this.preventDefault;
delete this.stopPropagation;
delete this.isDefaultPrevented;
delete this.isPropagationStopped;
}

this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
var Interface = this.constructor.Interface;

for (var propName in Interface) {

if (!Interface.hasOwnProperty(propName)) {
continue;
}

{
delete this[propName]; // this has a getter/setter for warnings
}

var normalize = Interface[propName];

if (normalize) {
this[propName] = normalize(nativeEvent);
} else {
if (propName === 'target') {
this.target = nativeEventTarget;
} else {
this[propName] = nativeEvent[propName];
}
}
}

var defaultPrevented = nativeEvent.defaultPrevented != null ?

nativeEvent.defaultPrevented : nativeEvent.returnValue === false;

if (defaultPrevented) {
this.isDefaultPrevented = functionThatReturnsTrue;
} else {
this.isDefaultPrevented = functionThatReturnsFalse;
}

this.isPropagationStopped = functionThatReturnsFalse;
return this;
}

_assign(SyntheticEvent.prototype, {
preventDefault: function () {
this.defaultPrevented = true;
var event = this.nativeEvent;
 if (!event) {
return;
}

if (event.preventDefault) {
event.preventDefault();
} else if (typeof event.returnValue !== 'unknown') {
event.returnValue = false;
}

this.isDefaultPrevented = functionThatReturnsTrue;
},
stopPropagation: function () {
var event = this.nativeEvent;

if (!event) {
return;
}

if (event.stopPropagation) {
event.stopPropagation();
} else if (typeof event.cancelBubble !== 'unknown') {
// The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// IE specific).
event.cancelBubble = true;
}

this.isPropagationStopped = functionThatReturnsTrue;
},

/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/
persist: function () {
this.isPersistent = functionThatReturnsTrue;
},

/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/
isPersistent: functionThatReturnsFalse,

/**
* `PooledClass` looks for `destructor` on each instance it releases.
*/
destructor: function () {
var Interface = this.constructor.Interface;

for (var propName in Interface) {

{
Object.defineProperty(this, propName,
getPooledWarningPropertyDefinition(propName, Interface[propName]));
 }
}

this.dispatchConfig = null;
this._targetInst = null;
this.nativeEvent = null;
this.isDefaultPrevented = functionThatReturnsFalse;
this.isPropagationStopped = functionThatReturnsFalse;
this._dispatchListeners = null;
this._dispatchInstances = null;

{
Object.defineProperty(this, 'nativeEvent',
getPooledWarningPropertyDefinition('nativeEvent', null));
Object.defineProperty(this, 'isDefaultPrevented',
getPooledWarningPropertyDefinition('isDefaultPrevented',
functionThatReturnsFalse));
Object.defineProperty(this, 'isPropagationStopped',
getPooledWarningPropertyDefinition('isPropagationStopped',
functionThatReturnsFalse));
Object.defineProperty(this, 'preventDefault',
getPooledWarningPropertyDefinition('preventDefault', function () {}));
Object.defineProperty(this, 'stopPropagation',
getPooledWarningPropertyDefinition('stopPropagation', function () {}));
}
}
});

SyntheticEvent.Interface = EventInterface;
/**
* Helper to reduce boilerplate when creating subclasses.
*/

SyntheticEvent.extend = function (Interface) {

var Super = this;

var E = function () {};

E.prototype = Super.prototype;
var prototype = new E();

function Class() {
return Super.apply(this, arguments);
}

_assign(prototype, Class.prototype);

Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = _assign({}, Super.Interface, Interface);
Class.extend = Super.extend;
addEventPoolingTo(Class);
return Class;
};

addEventPoolingTo(SyntheticEvent);
/**
* Helper to nullify syntheticEvent instance properties when destructing
*
 * @param {String} propName
* @param {?object} getVal
* @return {object} defineProperty object
*/

function getPooledWarningPropertyDefinition(propName, getVal) {

var isFunction = typeof getVal === 'function';
return {
configurable: true,
set: set,
get: get
};

function set(val) {
var action = isFunction ? 'setting the method' : 'setting the property';
warn(action, 'This is effectively a no-op');
return val;
}

function get() {
var action = isFunction ? 'accessing the method' : 'accessing the property';
var result = isFunction ? 'This is a no-op function' : 'This is set to null';
warn(action, result);
return getVal;
}

function warn(action, result) {

{
error("This synthetic event is reused for performance reasons. If you're
seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " +
'If you must keep the original synthetic event around, use event.persist(). ' +
'See https://fb.me/react-event-pooling for more information.', action, propName,
result);
}
}
}

function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {

var EventConstructor = this;

if (EventConstructor.eventPool.length) {
var instance = EventConstructor.eventPool.pop();
EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent,
nativeInst);
return instance;
}

return new EventConstructor(dispatchConfig, targetInst, nativeEvent,

nativeInst);
}

function releasePooledEvent(event) {
var EventConstructor = this;

if (!(event instanceof EventConstructor)) {

{
throw Error( "Trying to release an event instance into a pool of a
different type." );
}
 }

event.destructor();

if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {

EventConstructor.eventPool.push(event);
}
}

function addEventPoolingTo(EventConstructor) {
EventConstructor.eventPool = [];
EventConstructor.getPooled = getPooledEvent;
EventConstructor.release = releasePooledEvent;
}

/**
* `touchHistory` isn't actually on the native event, but putting it in the
* interface will ensure that it is cleaned up when pooled/destroyed. The
* `ResponderEventPlugin` will populate it appropriately.
*/

var ResponderSyntheticEvent = SyntheticEvent.extend({

touchHistory: function (nativeEvent) {
return null; // Actually doesn't even look at the native event.
}
});

// Note: ideally these would be imported from DOMTopLevelEventTypes,

// but our build system currently doesn't let us do that from a fork.
var TOP_TOUCH_START = 'touchstart';
var TOP_TOUCH_MOVE = 'touchmove';
var TOP_TOUCH_END = 'touchend';
var TOP_TOUCH_CANCEL = 'touchcancel';
var TOP_SCROLL = 'scroll';
var TOP_SELECTION_CHANGE = 'selectionchange';
var TOP_MOUSE_DOWN = 'mousedown';
var TOP_MOUSE_MOVE = 'mousemove';
var TOP_MOUSE_UP = 'mouseup';
function isStartish(topLevelType) {
return topLevelType === TOP_TOUCH_START || topLevelType === TOP_MOUSE_DOWN;
}
function isMoveish(topLevelType) {
return topLevelType === TOP_TOUCH_MOVE || topLevelType === TOP_MOUSE_MOVE;
}
function isEndish(topLevelType) {
return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL ||
topLevelType === TOP_MOUSE_UP;
}
var startDependencies = [TOP_TOUCH_START, TOP_MOUSE_DOWN];
var moveDependencies = [TOP_TOUCH_MOVE, TOP_MOUSE_MOVE];
var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END, TOP_MOUSE_UP];

/**
* Tracks the position and time of each active touch by `touch.identifier`. We
* should typically only see IDs in the range of 1-20 because IDs get recycled
* when touches end and start again.
*/

var MAX_TOUCH_BANK = 20;

var touchBank = [];
var touchHistory = {
touchBank: touchBank,
numberActiveTouches: 0,
// If there is only one active touch, we remember its location. This prevents
// us having to loop through all of the touches all the time in the most
// common case.
indexOfSingleActiveTouch: -1,
mostRecentTimeStamp: 0
};

function timestampForTouch(touch) {
// The legacy internal implementation provides "timeStamp", which has been
// renamed to "timestamp". Let both work for now while we iron it out
// TODO (evv): rename timeStamp to timestamp in internal code
return touch.timeStamp || touch.timestamp;
}
/**
* TODO: Instead of making gestures recompute filtered velocity, we could
* include a built in velocity computation that can be reused globally.
*/

function createTouchRecord(touch) {
return {
touchActive: true,
startPageX: touch.pageX,
startPageY: touch.pageY,
startTimeStamp: timestampForTouch(touch),
currentPageX: touch.pageX,
currentPageY: touch.pageY,
currentTimeStamp: timestampForTouch(touch),
previousPageX: touch.pageX,
previousPageY: touch.pageY,
previousTimeStamp: timestampForTouch(touch)
};
}

function resetTouchRecord(touchRecord, touch) {

touchRecord.touchActive = true;
touchRecord.startPageX = touch.pageX;
touchRecord.startPageY = touch.pageY;
touchRecord.startTimeStamp = timestampForTouch(touch);
touchRecord.currentPageX = touch.pageX;
touchRecord.currentPageY = touch.pageY;
touchRecord.currentTimeStamp = timestampForTouch(touch);
touchRecord.previousPageX = touch.pageX;
touchRecord.previousPageY = touch.pageY;
touchRecord.previousTimeStamp = timestampForTouch(touch);
}

function getTouchIdentifier(_ref) {
var identifier = _ref.identifier;

if (!(identifier != null)) {
{
throw Error( "Touch object is missing identifier." );
}
}
 {
if (identifier > MAX_TOUCH_BANK) {
error('Touch identifier %s is greater than maximum supported %s which
causes ' + 'performance issues backfilling array locations for all of the
indices.', identifier, MAX_TOUCH_BANK);
}
}

return identifier;
}

function recordTouchStart(touch) {
var identifier = getTouchIdentifier(touch);
var touchRecord = touchBank[identifier];

if (touchRecord) {
resetTouchRecord(touchRecord, touch);
} else {
touchBank[identifier] = createTouchRecord(touch);
}

touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
}

function recordTouchMove(touch) {
var touchRecord = touchBank[getTouchIdentifier(touch)];

if (touchRecord) {
touchRecord.touchActive = true;
touchRecord.previousPageX = touchRecord.currentPageX;
touchRecord.previousPageY = touchRecord.currentPageY;
touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
touchRecord.currentPageX = touch.pageX;
touchRecord.currentPageY = touch.pageY;
touchRecord.currentTimeStamp = timestampForTouch(touch);
touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
} else {
{
warn('Cannot record touch move without a touch start.\n' + 'Touch Move:
%s\n' + 'Touch Bank: %s', printTouch(touch), printTouchBank());
}
}
}

function recordTouchEnd(touch) {
var touchRecord = touchBank[getTouchIdentifier(touch)];

if (touchRecord) {
touchRecord.touchActive = false;
touchRecord.previousPageX = touchRecord.currentPageX;
touchRecord.previousPageY = touchRecord.currentPageY;
touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
touchRecord.currentPageX = touch.pageX;
touchRecord.currentPageY = touch.pageY;
touchRecord.currentTimeStamp = timestampForTouch(touch);
touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
} else {
{
 warn('Cannot record touch end without a touch start.\n' + 'Touch End: %s\n'
+ 'Touch Bank: %s', printTouch(touch), printTouchBank());
}
}
}

function printTouch(touch) {
return JSON.stringify({
identifier: touch.identifier,
pageX: touch.pageX,
pageY: touch.pageY,
timestamp: timestampForTouch(touch)
});
}

function printTouchBank() {
var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));

if (touchBank.length > MAX_TOUCH_BANK) {

printed += ' (original size: ' + touchBank.length + ')';
}

return printed;
}

var ResponderTouchHistoryStore = {
recordTouchTrack: function (topLevelType, nativeEvent) {
if (isMoveish(topLevelType)) {
nativeEvent.changedTouches.forEach(recordTouchMove);
} else if (isStartish(topLevelType)) {
nativeEvent.changedTouches.forEach(recordTouchStart);
touchHistory.numberActiveTouches = nativeEvent.touches.length;

if (touchHistory.numberActiveTouches === 1) {
touchHistory.indexOfSingleActiveTouch =
nativeEvent.touches[0].identifier;
}
} else if (isEndish(topLevelType)) {
nativeEvent.changedTouches.forEach(recordTouchEnd);
touchHistory.numberActiveTouches = nativeEvent.touches.length;

if (touchHistory.numberActiveTouches === 1) {
for (var i = 0; i < touchBank.length; i++) {
var touchTrackToCheck = touchBank[i];

if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {

touchHistory.indexOfSingleActiveTouch = i;
break;
}
}

{
var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];

if (activeRecord == null || !activeRecord.touchActive) {

error('Cannot find single active touch.');
}
}
}
 }
},
touchHistory: touchHistory
};

/**
* Accumulates items that must not be null or undefined.
*
* This is used to conserve memory by avoiding array allocations.
*
* @return {*|array<*>} An accumulation of items.
*/

function accumulate(current, next) {

if (!(next != null)) {
{
throw Error( "accumulate(...): Accumulated items must not be null or
undefined." );
}
}

if (current == null) {
return next;
} // Both are not empty. Warning: Never call x.concat(y) when you are not
// certain that x is an Array (x could be a string with concat method).

if (Array.isArray(current)) {
return current.concat(next);
}

if (Array.isArray(next)) {
return [current].concat(next);
}

return [current, next];

}

/**
* Instance of element that should respond to touch/move types of interactions,
* as indicated explicitly by relevant callbacks.
*/

var responderInst = null;

/**
* Count of current touches. A textInput should become responder iff the
* selection changes while there is a touch on the screen.
*/

var trackedTouchCount = 0;

var changeResponder = function (nextResponderInst, blockHostResponder) {

var oldResponderInst = responderInst;
responderInst = nextResponderInst;

if (ResponderEventPlugin.GlobalResponderHandler !== null) {

ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst,
nextResponderInst, blockHostResponder);
}
};

var eventTypes = {
/**
* On a `touchStart`/`mouseDown`, is it desired that this element become the
* responder?
*/
startShouldSetResponder: {
phasedRegistrationNames: {
bubbled: 'onStartShouldSetResponder',
captured: 'onStartShouldSetResponderCapture'
},
dependencies: startDependencies
},

/**
* On a `scroll`, is it desired that this element become the responder? This
* is usually not needed, but should be used to retroactively infer that a
* `touchStart` had occurred during momentum scroll. During a momentum scroll,
* a touch start will be immediately followed by a scroll event if the view is
* currently scrolling.
*
* TODO: This shouldn't bubble.
*/
scrollShouldSetResponder: {
phasedRegistrationNames: {
bubbled: 'onScrollShouldSetResponder',
captured: 'onScrollShouldSetResponderCapture'
},
dependencies: [TOP_SCROLL]
},

/**
* On text selection change, should this element become the responder? This
* is needed for text inputs or other views with native selection, so the
* JS view can claim the responder.
*
* TODO: This shouldn't bubble.
*/
selectionChangeShouldSetResponder: {
phasedRegistrationNames: {
bubbled: 'onSelectionChangeShouldSetResponder',
captured: 'onSelectionChangeShouldSetResponderCapture'
},
dependencies: [TOP_SELECTION_CHANGE]
},

/**
* On a `touchMove`/`mouseMove`, is it desired that this element become the
* responder?
*/
moveShouldSetResponder: {
phasedRegistrationNames: {
bubbled: 'onMoveShouldSetResponder',
captured: 'onMoveShouldSetResponderCapture'
},
dependencies: moveDependencies
},
 /**
* Direct responder events dispatched directly to responder. Do not bubble.
*/
responderStart: {
registrationName: 'onResponderStart',
dependencies: startDependencies
},
responderMove: {
registrationName: 'onResponderMove',
dependencies: moveDependencies
},
responderEnd: {
registrationName: 'onResponderEnd',
dependencies: endDependencies
},
responderRelease: {
registrationName: 'onResponderRelease',
dependencies: endDependencies
},
responderTerminationRequest: {
registrationName: 'onResponderTerminationRequest',
dependencies: []
},
responderGrant: {
registrationName: 'onResponderGrant',
dependencies: []
},
responderReject: {
registrationName: 'onResponderReject',
dependencies: []
},
responderTerminate: {
registrationName: 'onResponderTerminate',
dependencies: []
}
};
/**
*
* Responder System:
* ----------------
*
* - A global, solitary "interaction lock" on a view.
* - If a node becomes the responder, it should convey visual feedback
* immediately to indicate so, either by highlighting or moving accordingly.
* - To be the responder means, that touches are exclusively important to that
* responder view, and no other view.
* - While touches are still occurring, the responder lock can be transferred to
* a new view, but only to increasingly "higher" views (meaning ancestors of
* the current responder).
*
* Responder being granted:
* ------------------------
*
* - Touch starts, moves, and scrolls can cause an ID to become the responder.
* - We capture/bubble `startShouldSetResponder`/`moveShouldSetResponder` to
* the "appropriate place".
* - If nothing is currently the responder, the "appropriate place" is the
* initiating event's `targetID`.
* - If something *is* already the responder, the "appropriate place" is the
 * first common ancestor of the event target and the current `responderInst`.
* - Some negotiation happens: See the timing diagram below.
* - Scrolled views automatically become responder. The reasoning is that a
* platform scroll view that isn't built on top of the responder system has
* began scrolling, and the active responder must now be notified that the
* interaction is no longer locked to it - the system has taken over.
*
* - Responder being released:
* As soon as no more touches that *started* inside of descendants of the
* *current* responderInst, an `onResponderRelease` event is dispatched to the
* current responder, and the responder lock is released.
*
* TODO:
* - on "end", a callback hook for `onResponderEndShouldRemainResponder` that
* determines if the responder lock should remain.
* - If a view shouldn't "remain" the responder, any active touches should by
* default be considered "dead" and do not influence future negotiations or
* bubble paths. It should be as if those touches do not exist.
* -- For multitouch: Usually a translate-z will choose to "remain" responder
* after one out of many touches ended. For translate-y, usually the view
* doesn't wish to "remain" responder after one of many touches end.
* - Consider building this on top of a `stopPropagation` model similar to
* `W3C` events.
* - Ensure that `onResponderTerminate` is called on touch cancels, whether or
* not `onResponderTerminationRequest` returns `true` or `false`.
*
*/

/* Negotiation Performed
+-----------------------+
/ \
Process low level events to + Current Responder + wantsResponderID
determine who to perform negot-| (if any exists at all) |
iation/transition | Otherwise just pass through|
-------------------------------+----------------------------+------------------+
Bubble to find first ID | |
to return true:wantsResponderID| |
| |
+-------------+ | |
| onTouchStart| | |
+------+------+ none | |
| return| |
+-----------v-------------+true| +------------------------+ |
|onStartShouldSetResponder|----->|onResponderStart (cur) |<-----------+
+-----------+-------------+ | +------------------------+ | |
| | | +--------+-------+
| returned true for| false:REJECT +-------->|onResponderReject
| wantsResponderID | | | +----------------+
| (now attempt | +------------------+-----+ |
| handoff) | | onResponder | |
+------------------->| TerminationRequest| |
| +------------------+-----+ |
| | | +----------------+
| true:GRANT +-------->|onResponderGrant|
| | +--------+-------+
| +------------------------+ | |
| | onResponderTerminate |<-----------+
| +------------------+-----+ |
| | | +----------------+
 | +-------->|onResponderStart|
| | +----------------+
Bubble to find first ID | |
to return true:wantsResponderID| |
| |
+-------------+ | |
| onTouchMove | | |
+------+------+ none | |
| return| |
+-----------v-------------+true| +------------------------+ |
|onMoveShouldSetResponder |----->|onResponderMove (cur) |<-----------+
+-----------+-------------+ | +------------------------+ | |
| | | +--------+-------+
| returned true for| false:REJECT +-------->|onResponderRejec|
| wantsResponderID | | | +----------------+
| (now attempt | +------------------+-----+ |
| handoff) | | onResponder | |
+------------------->| TerminationRequest| |
| +------------------+-----+ |
| | | +----------------+
| true:GRANT +-------->|onResponderGrant|
| | +--------+-------+
| +------------------------+ | |
| | onResponderTerminate |<-----------+
| +------------------+-----+ |
| | | +----------------+
| +-------->|onResponderMove |
| | +----------------+
| |
| |
Some active touch started| |
inside current responder | +------------------------+ |
+------------------------->| onResponderEnd | |
| | +------------------------+ |
+---+---------+ | |
| onTouchEnd | | |
+---+---------+ | |
| | +------------------------+ |
+------------------------->| onResponderEnd | |
No active touches started| +-----------+------------+ |
inside current responder | | |
| v |
| +------------------------+ |
| | onResponderRelease | |
| +------------------------+ |
| |
+ + */

/**
* A note about event ordering in the `EventPluginRegistry`.
*
* Suppose plugins are injected in the following order:
*
* `[R, S, C]`
*
* To help illustrate the example, assume `S` is `SimpleEventPlugin` (for
* `onClick` etc) and `R` is `ResponderEventPlugin`.
*
* "Deferred-Dispatched Events":
 *
* - The current event plugin system will traverse the list of injected plugins,
* in order, and extract events by collecting the plugin's return value of
* `extractEvents()`.
* - These events that are returned from `extractEvents` are "deferred
* dispatched events".
* - When returned from `extractEvents`, deferred-dispatched events contain an
* "accumulation" of deferred dispatches.
* - These deferred dispatches are accumulated/collected before they are
* returned, but processed at a later time by the `EventPluginRegistry` (hence
the
* name deferred).
*
* In the process of returning their deferred-dispatched events, event plugins
* themselves can dispatch events on-demand without returning them from
* `extractEvents`. Plugins might want to do this, so that they can use event
* dispatching as a tool that helps them decide which events should be extracted
* in the first place.
*
* "On-Demand-Dispatched Events":
*
* - On-demand-dispatched events are not returned from `extractEvents`.
* - On-demand-dispatched events are dispatched during the process of returning
* the deferred-dispatched events.
* - They should not have side effects.
* - They should be avoided, and/or eventually be replaced with another
* abstraction that allows event plugins to perform multiple "rounds" of event
* extraction.
*
* Therefore, the sequence of event dispatches becomes:
*
* - `R`s on-demand events (if any) (dispatched by `R` on-demand)
* - `S`s on-demand events (if any) (dispatched by `S` on-demand)
* - `C`s on-demand events (if any) (dispatched by `C` on-demand)
* - `R`s extracted events (if any) (dispatched by `EventPluginRegistry`)
* - `S`s extracted events (if any) (dispatched by `EventPluginRegistry`)
* - `C`s extracted events (if any) (dispatched by `EventPluginRegistry`)
*
* In the case of `ResponderEventPlugin`: If the `startShouldSetResponder`
* on-demand dispatch returns `true` (and some other details are satisfied) the
* `onResponderGrant` deferred dispatched event is returned from
* `extractEvents`. The sequence of dispatch executions in this case
* will appear as follows:
*
* - `startShouldSetResponder` (`ResponderEventPlugin` dispatches on-demand)
* - `touchStartCapture` (`EventPluginRegistry` dispatches as usual)
* - `touchStart` (`EventPluginRegistry` dispatches as usual)
* - `responderGrant/Reject` (`EventPluginRegistry` dispatches as usual)
*/

function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent,

nativeEventTarget) {
var shouldSetEventType = isStartish(topLevelType) ?
eventTypes.startShouldSetResponder : isMoveish(topLevelType) ?
eventTypes.moveShouldSetResponder : topLevelType === TOP_SELECTION_CHANGE ?
eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
// TODO: stop one short of the current responder.

var bubbleShouldSetFrom = !responderInst ? targetInst :

getLowestCommonAncestor(responderInst, targetInst); // When capturing/bubbling the
"shouldSet" event, we want to skip the target
// (deepest ID) if it happens to be the current responder. The reasoning:
// It's strange to get an `onMoveShouldSetResponder` when you're *already*
// the responder.

var skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst;

var shouldSetEvent = ResponderSyntheticEvent.getPooled(shouldSetEventType,
bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
shouldSetEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;

if (skipOverBubbleShouldSetFrom) {
accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent);
} else {
accumulateTwoPhaseDispatches(shouldSetEvent);
}

var wantsResponderInst = executeDispatchesInOrderStopAtTrue(shouldSetEvent);

if (!shouldSetEvent.isPersistent()) {
shouldSetEvent.constructor.release(shouldSetEvent);
}

if (!wantsResponderInst || wantsResponderInst === responderInst) {

return null;
}

var extracted;
var grantEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant,
wantsResponderInst, nativeEvent, nativeEventTarget);
grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(grantEvent);
var blockHostResponder = executeDirectDispatch(grantEvent) === true;

if (responderInst) {
var terminationRequestEvent =
ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest,
responderInst, nativeEvent, nativeEventTarget);
terminationRequestEvent.touchHistory =
ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(terminationRequestEvent);
var shouldSwitch = !hasDispatches(terminationRequestEvent) ||
executeDirectDispatch(terminationRequestEvent);

if (!terminationRequestEvent.isPersistent()) {
terminationRequestEvent.constructor.release(terminationRequestEvent);
}

if (shouldSwitch) {
var terminateEvent =
ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst,
nativeEvent, nativeEventTarget);
terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(terminateEvent);
extracted = accumulate(extracted, [grantEvent, terminateEvent]);
changeResponder(wantsResponderInst, blockHostResponder);
} else {
var rejectEvent =
ResponderSyntheticEvent.getPooled(eventTypes.responderReject, wantsResponderInst,
nativeEvent, nativeEventTarget);
rejectEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(rejectEvent);
extracted = accumulate(extracted, rejectEvent);
}
} else {
extracted = accumulate(extracted, grantEvent);
changeResponder(wantsResponderInst, blockHostResponder);
}

return extracted;
}
/**
* A transfer is a negotiation between a currently set responder and the next
* element to claim responder status. Any start event could trigger a transfer
* of responderInst. Any move event could trigger a transfer.
*
* @param {string} topLevelType Record from `BrowserEventConstants`.
* @return {boolean} True if a transfer of responder could possibly occur.
*/

function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {

return topLevelInst && ( // responderIgnoreScroll: We are trying to migrate
away from specifically
// tracking native scroll events here and responderIgnoreScroll indicates we
// will send topTouchCancel to handle canceling touch events instead
topLevelType === TOP_SCROLL && !nativeEvent.responderIgnoreScroll ||
trackedTouchCount > 0 && topLevelType === TOP_SELECTION_CHANGE ||
isStartish(topLevelType) || isMoveish(topLevelType));
}
/**
* Returns whether or not this touch end event makes it such that there are no
* longer any touches that started inside of the current `responderInst`.
*
* @param {NativeEvent} nativeEvent Native touch end event.
* @return {boolean} Whether or not this touch end event ends the responder.
*/

function noResponderTouches(nativeEvent) {
var touches = nativeEvent.touches;

if (!touches || touches.length === 0) {

return true;
}

for (var i = 0; i < touches.length; i++) {

var activeTouch = touches[i];
var target = activeTouch.target;

if (target !== null && target !== undefined && target !== 0) {
// Is the original touch location inside of the current responder?
var targetInst = getInstanceFromNode(target);

if (isAncestor(responderInst, targetInst)) {
return false;
}
}
 }

return true;
}

var ResponderEventPlugin = {
/* For unit testing only */
_getResponder: function () {
return responderInst;
},
eventTypes: eventTypes,

/**
* We must be resilient to `targetInst` being `null` on `touchMove` or
* `touchEnd`. On certain platforms, this means that a native scroll has
* assumed control and the original touch targets are destroyed.
*/
extractEvents: function (topLevelType, targetInst, nativeEvent,
nativeEventTarget, eventSystemFlags) {
if (isStartish(topLevelType)) {
trackedTouchCount += 1;
} else if (isEndish(topLevelType)) {
if (trackedTouchCount >= 0) {
trackedTouchCount -= 1;
} else {
{
warn('Ended a touch event which was not counted in
`trackedTouchCount`.');
}

return null;
}
}

ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ?
setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent,
nativeEventTarget) : null; // Responder may or may not have transferred on a new
touch start/move.
// Regardless, whoever is the responder after any potential transfer, we
// direct all touch start/move/ends to them in the form of
// `onResponderMove/Start/End`. These will be called for *every* additional
// finger that move/start/end, dispatched directly to whoever is the
// current responder at that moment, until the responder is "released".
//
// These multiple individual change touch events are are always bookended
// by `onResponderGrant`, and one of
// (`onResponderRelease/onResponderTerminate`).

var isResponderTouchStart = responderInst && isStartish(topLevelType);

var isResponderTouchMove = responderInst && isMoveish(topLevelType);
var isResponderTouchEnd = responderInst && isEndish(topLevelType);
var incrementalTouch = isResponderTouchStart ? eventTypes.responderStart :
isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ?
eventTypes.responderEnd : null;

if (incrementalTouch) {
var gesture = ResponderSyntheticEvent.getPooled(incrementalTouch,
responderInst, nativeEvent, nativeEventTarget);
 gesture.touchHistory = ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(gesture);
extracted = accumulate(extracted, gesture);
}

var isResponderTerminate = responderInst && topLevelType ===

TOP_TOUCH_CANCEL;
var isResponderRelease = responderInst && !isResponderTerminate &&
isEndish(topLevelType) && noResponderTouches(nativeEvent);
var finalTouch = isResponderTerminate ? eventTypes.responderTerminate :
isResponderRelease ? eventTypes.responderRelease : null;

if (finalTouch) {
var finalEvent = ResponderSyntheticEvent.getPooled(finalTouch,
responderInst, nativeEvent, nativeEventTarget);
finalEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
accumulateDirectDispatches(finalEvent);
extracted = accumulate(extracted, finalEvent);
changeResponder(null);
}

return extracted;
},
GlobalResponderHandler: null,
injection: {
/**
* @param {{onChange: (ReactID, ReactID) => void} GlobalResponderHandler
* Object that handles any change in responder. Use this to inject
* integration with an existing touch handling system etc.
*/
injectGlobalResponderHandler: function (GlobalResponderHandler) {
ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
}
}
};

// Keep in sync with ReactDOM.js, ReactTestUtils.js, and ReactTestUtilsAct.js:

var _ReactDOM$__SECRET_IN =
ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
getInstanceFromNode$1 = _ReactDOM$__SECRET_IN[0],
getNodeFromInstance$1 = _ReactDOM$__SECRET_IN[1],
getFiberCurrentPropsFromNode$1 = _ReactDOM$__SECRET_IN[2],
injectEventPluginsByName = _ReactDOM$__SECRET_IN[3];
setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromNode$1,
getNodeFromInstance$1);

var ReactDOMUnstableNativeDependencies = /*#__PURE__*/Object.freeze({

__proto__: null,
ResponderEventPlugin: ResponderEventPlugin,
ResponderTouchHistoryStore: ResponderTouchHistoryStore,
injectEventPluginsByName: injectEventPluginsByName
});

var unstableNativeDependencies = ReactDOMUnstableNativeDependencies;

return unstableNativeDependencies;

})));