)
+
+ if (tag === HostComponent && stateNode !== null) {
+ lastHostComponent = stateNode; // createEventHandle listeners
+
+ if (reactEventName !== null) {
+ var listener = getListener(instance, reactEventName);
+ if (listener != null) {
+ listeners.push(createDispatchListener(instance, listener, lastHostComponent));
+ }
+ }
+ } // If we are only accumulating events for the target, then we don't
+ // continue to propagate through the React fiber tree to find other
+ // listeners.
+
+ if (accumulateTargetOnly) {
+ break;
+ } // If we are processing the onBeforeBlur event, then we need to take
+
+ instance = instance.return;
+ }
+ return listeners;
+ } // We should only use this function for:
+ // - BeforeInputEventPlugin
+ // - ChangeEventPlugin
+ // - SelectEventPlugin
+ // This is because we only process these plugins
+ // in the bubble phase, so we need to accumulate two
+ // phase event listeners (via emulation).
+
+ function accumulateTwoPhaseListeners(targetFiber, reactName) {
+ var captureName = reactName + 'Capture';
+ var listeners = [];
+ var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+ while (instance !== null) {
+ var _instance3 = instance,
+ stateNode = _instance3.stateNode,
+ tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e.
)
+
+ if (tag === HostComponent && stateNode !== null) {
+ var currentTarget = stateNode;
+ var captureListener = getListener(instance, captureName);
+ if (captureListener != null) {
+ listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+ }
+ var bubbleListener = getListener(instance, reactName);
+ if (bubbleListener != null) {
+ listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+ }
+ }
+ instance = instance.return;
+ }
+ return listeners;
+ }
+ function getParent(inst) {
+ if (inst === null) {
+ return null;
+ }
+ 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 nodeA = instA;
+ var nodeB = instB;
+ var depthA = 0;
+ for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
+ depthA++;
+ }
+ var depthB = 0;
+ for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
+ depthB++;
+ } // If A is deeper, crawl up.
+
+ while (depthA - depthB > 0) {
+ nodeA = getParent(nodeA);
+ depthA--;
+ } // If B is deeper, crawl up.
+
+ while (depthB - depthA > 0) {
+ nodeB = getParent(nodeB);
+ depthB--;
+ } // Walk in lockstep until we find a match.
+
+ var depth = depthA;
+ while (depth--) {
+ if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {
+ return nodeA;
+ }
+ nodeA = getParent(nodeA);
+ nodeB = getParent(nodeB);
+ }
+ return null;
+ }
+ function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+ var registrationName = event._reactName;
+ var listeners = [];
+ var instance = target;
+ while (instance !== null) {
+ if (instance === common) {
+ break;
+ }
+ var _instance4 = instance,
+ alternate = _instance4.alternate,
+ stateNode = _instance4.stateNode,
+ tag = _instance4.tag;
+ if (alternate !== null && alternate === common) {
+ break;
+ }
+ if (tag === HostComponent && stateNode !== null) {
+ var currentTarget = stateNode;
+ if (inCapturePhase) {
+ var captureListener = getListener(instance, registrationName);
+ if (captureListener != null) {
+ listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));
+ }
+ } else if (!inCapturePhase) {
+ var bubbleListener = getListener(instance, registrationName);
+ if (bubbleListener != null) {
+ listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));
+ }
+ }
+ }
+ instance = instance.return;
+ }
+ if (listeners.length !== 0) {
+ dispatchQueue.push({
+ event: event,
+ listeners: listeners
+ });
+ }
+ } // We should only use this function for:
+ // - EnterLeaveEventPlugin
+ // This is because we only process this plugin
+ // in the bubble phase, so we need to accumulate two
+ // phase event listeners.
+
+ function accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {
+ var common = from && to ? getLowestCommonAncestor(from, to) : null;
+ if (from !== null) {
+ accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);
+ }
+ if (to !== null && enterEvent !== null) {
+ accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);
+ }
+ }
+ function getListenerSetKey(domEventName, capture) {
+ return domEventName + "__" + (capture ? 'capture' : 'bubble');
+ }
+ var didWarnInvalidHydration = false;
+ var DANGEROUSLY_SET_INNER_HTML = 'dangerouslySetInnerHTML';
+ var SUPPRESS_CONTENT_EDITABLE_WARNING = 'suppressContentEditableWarning';
+ var SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';
+ var AUTOFOCUS = 'autoFocus';
+ var CHILDREN = 'children';
+ var STYLE = 'style';
+ var HTML$1 = '__html';
+ var warnedUnknownTags;
+ var validatePropertiesInDevelopment;
+ var warnForPropDifference;
+ var warnForExtraAttributes;
+ var warnForInvalidEventListener;
+ var canDiffStyleForHydrationWarning;
+ var normalizeHTML;
+ {
+ warnedUnknownTags = {
+ // There are working polyfills for