react-dom 16.10.2 → 16.13.1

package/umd/react-dom-test-utils.development.js

@@ -1,4 +1,4 @@
-/** @license React v16.10.2
+/** @license React v16.13.1
  * react-dom-test-utils.development.js
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
@@ -10,1683 +10,1490 @@
 'use strict';
 
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('react-dom')) :
-	typeof define === 'function' && define.amd ? define(['react', 'react-dom'], factory) :
-	(global.ReactTestUtils = factory(global.React,global.ReactDOM));
-}(this, (function (React,ReactDOM) { 'use strict';
-
-var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-var _assign = ReactInternals.assign;
-
-// Do not require this module directly! Use normal `invariant` calls with
-// template literal strings. The messages will be converted to ReactError during
-// build, and in production they will be minified.
-
-// Do not require this module directly! Use normal `invariant` calls with
-// template literal strings. The messages will be converted to ReactError during
-// build, and in production they will be minified.
-function ReactError(error) {
-  error.name = 'Invariant Violation';
-  return error;
-}
-
-/**
- * Use invariant() to assert state which your program assumes to be true.
- *
- * Provide sprintf-style format (only %s is supported) and arguments
- * to provide information about what broke and what you were
- * expecting.
- *
- * The invariant message will be stripped in production, but the invariant
- * will remain to ensure logic does not differ in production.
- */
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('react-dom')) :
+  typeof define === 'function' && define.amd ? define(['react', 'react-dom'], factory) :
+  (global = global || self, global.ReactTestUtils = factory(global.React, global.ReactDOM));
+}(this, (function (React, ReactDOM) { 'use strict';
 
-/**
- * Similar to invariant but only logs a warning if the condition is not met.
- * This can be used to log issues in development environments in critical
- * paths. Removing the logging code for production environments will keep the
- * same logic and follow the same code paths.
- */
-var warningWithoutStack = function () {};
+  var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  var _assign = ReactInternals.assign;
 
-{
-  warningWithoutStack = function (condition, format) {
-    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-      args[_key - 2] = arguments[_key];
-    }
+  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 (format === undefined) {
-      throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
-    }
+  if (!ReactSharedInternals.hasOwnProperty('ReactCurrentDispatcher')) {
+    ReactSharedInternals.ReactCurrentDispatcher = {
+      current: null
+    };
+  }
 
-    if (args.length > 8) {
-      // Check before the condition to catch violations early.
-      throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
-    }
+  if (!ReactSharedInternals.hasOwnProperty('ReactCurrentBatchConfig')) {
+    ReactSharedInternals.ReactCurrentBatchConfig = {
+      suspense: null
+    };
+  }
 
-    if (condition) {
-      return;
-    }
+  // 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.
 
-    if (typeof console !== 'undefined') {
-      var argsWithFormat = args.map(function (item) {
-        return '' + item;
-      });
-      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
-      // breaks IE9: https://github.com/facebook/react/issues/13610
+  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];
+      }
 
-      Function.prototype.apply.call(console.error, console, argsWithFormat);
+      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];
+      }
 
-    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) {}
-  };
-}
-
-var warningWithoutStack$1 = warningWithoutStack;
-
-/**
- * `ReactInstanceMap` maintains a mapping from a public facing stateful
- * instance (key) and the internal representation (value). This allows public
- * methods to accept the user facing instance as an argument and map them back
- * to internal methods.
- *
- * Note that this module is currently shared and assumed to be stateless.
- * If this becomes an actual Map, that will break.
- */
-
-/**
- * This API should be called `delete` but we'd have to make sure to always
- * transform these to strings for IE support. When this transform is fully
- * supported we can rename it.
- */
-
-function get(key) {
-  return key._reactInternalFiber;
-}
-
-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
-  };
-}
-
-// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
-// nor polyfill, then a plain number is used for performance.
-
-
-
-
-
-
- // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
-// (unstable) APIs that have been removed. Can we remove the symbols?
-
-{
-  
-}
-
-var FunctionComponent = 0;
-var ClassComponent = 1;
- // Before we know whether it is function or class
-
-var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
-
- // A subtree. Could be an entry point to a different renderer.
-
-var HostComponent = 5;
-var HostText = 6;
-
-// Don't change these two values. They're used by React Dev Tools.
-var NoEffect =
-/*              */
-0;
- // You can change the rest (and add more).
-
-var Placement =
-/*             */
-2;
-
-
-
-
-
-
-
-
-
-var Hydrating =
-/*             */
-1024;
- // Passive & Update & Callback & Ref & Snapshot
-
- // Union of all host effects
-
-// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:
-
- // In some cases, StrictMode should also double-render lifecycles.
-// This can be confusing for tests though,
-// And it can be bad for performance in production.
-// This feature flag can be used to control the behavior:
-
- // To preserve the "Pause on caught exceptions" behavior of the debugger, we
-// replay the begin phase of a failed component inside invokeGuardedCallback.
-
- // Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:
-
- // Gather advanced timing metrics for Profiler subtrees.
-
- // Trace which interactions trigger each commit.
-
- // Only used in www builds.
-
- // TODO: true? Here it might just be false.
-
- // Only used in www builds.
-
- // Only used in www builds.
+      printWarning('error', format, args);
+    }
+  }
 
- // Disable javascript: URL strings in href for XSS protection.
+  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;
 
- // React Fire: prevent the value and checked attributes from syncing
-// with their related DOM properties
+      if (!hasExistingStack) {
+        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+        var stack = ReactDebugCurrentFrame.getStackAddendum();
 
- // These APIs will no longer be "unstable" in the upcoming 16.7 release,
-// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.
+        if (stack !== '') {
+          format += '%s';
+          args = args.concat([stack]);
+        }
+      }
 
+      var argsWithFormat = args.map(function (item) {
+        return '' + item;
+      }); // Careful: RN currently depends on this prefix
 
- // See https://github.com/react-native-community/discussions-and-proposals/issues/72 for more information
-// This is a flag so we can fix warnings in RN core before turning it on
+      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
 
- // Experimental React Flare event system and event components support.
+      Function.prototype.apply.call(console[level], console, argsWithFormat);
 
- // Experimental Host Component support.
+      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) {}
+    }
+  }
 
- // Experimental Scope support.
+  /**
+   * `ReactInstanceMap` maintains a mapping from a public facing stateful
+   * instance (key) and the internal representation (value). This allows public
+   * methods to accept the user facing instance as an argument and map them back
+   * to internal methods.
+   *
+   * Note that this module is currently shared and assumed to be stateless.
+   * If this becomes an actual Map, that will break.
+   */
+  function get(key) {
+    return key._reactInternalFiber;
+  }
 
- // New API for JSX transforms to target - https://github.com/reactjs/rfcs/pull/107
+  var FunctionComponent = 0;
+  var ClassComponent = 1;
 
- // We will enforce mocking scheduler with scheduler/unstable_mock at some point. (v17?)
-// Till then, we warn about the missing mock, but still fallback to a sync mode compatible version
+  var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
 
- // For tests, we flush suspense fallbacks in an act scope;
-// *except* in some of our own tests, where we test incremental loading states.
+  var HostComponent = 5;
+  var HostText = 6;
 
- // Changes priority of some events like mousemove to user-blocking priority,
-// but without making them discrete. The flag exists in case it causes
-// starvation problems.
+  // Don't change these two values. They're used by React Dev Tools.
+  var NoEffect =
+  /*              */
+  0;
 
- // Add a callback property to suspense to notify which promises are currently
-// in the update queue. This allows reporting and tracing of what is causing
-// the user to see a loading state.
-// Also allows hydration callbacks to fire when a dehydrated boundary gets
-// hydrated or deleted.
+  var Placement =
+  /*             */
+  2;
+  var Hydrating =
+  /*             */
+  1024;
 
- // Part of the simplification of React.createElement so we can eventually move
-// from React.createElement to React.jsx
-// https://github.com/reactjs/rfcs/blob/createlement-rfc/text/0000-create-element-changes.md
+  var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+  function getNearestMountedFiber(fiber) {
+    var node = fiber;
+    var nearestMounted = fiber;
 
-var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
-function getNearestMountedFiber(fiber) {
-  var node = fiber;
-  var nearestMounted = fiber;
+    if (!fiber.alternate) {
+      // If there is no alternate, this might be a new tree that isn't inserted
+      // yet. If it is, then it will have a pending insertion effect on it.
+      var nextNode = node;
 
-  if (!fiber.alternate) {
-    // If there is no alternate, this might be a new tree that isn't inserted
-    // yet. If it is, then it will have a pending insertion effect on it.
-    var nextNode = node;
+      do {
+        node = nextNode;
 
-    do {
-      node = nextNode;
+        if ((node.effectTag & (Placement | Hydrating)) !== NoEffect) {
+          // This is an insertion or in-progress hydration. The nearest possible
+          // mounted fiber is the parent but we need to continue to figure out
+          // if that one is still mounted.
+          nearestMounted = node.return;
+        }
 
-      if ((node.effectTag & (Placement | Hydrating)) !== NoEffect) {
-        // This is an insertion or in-progress hydration. The nearest possible
-        // mounted fiber is the parent but we need to continue to figure out
-        // if that one is still mounted.
-        nearestMounted = node.return;
+        nextNode = node.return;
+      } while (nextNode);
+    } else {
+      while (node.return) {
+        node = node.return;
       }
-
-      nextNode = node.return;
-    } while (nextNode);
-  } else {
-    while (node.return) {
-      node = node.return;
     }
-  }
-
-  if (node.tag === HostRoot) {
-    // TODO: Check if this was a nested HostRoot when used with
-    // renderContainerIntoSubtree.
-    return nearestMounted;
-  } // If we didn't hit the root, that means that we're in an disconnected tree
-  // that has been unmounted.
-
-
-  return null;
-}
-
 
+    if (node.tag === HostRoot) {
+      // TODO: Check if this was a nested HostRoot when used with
+      // renderContainerIntoSubtree.
+      return nearestMounted;
+    } // If we didn't hit the root, that means that we're in an disconnected tree
+    // that has been unmounted.
 
 
+    return null;
+  }
 
-function assertIsMounted(fiber) {
-  (function () {
+  function assertIsMounted(fiber) {
     if (!(getNearestMountedFiber(fiber) === fiber)) {
       {
-        throw ReactError(Error("Unable to find node on an unmounted component."));
+        throw Error( "Unable to find node on an unmounted component." );
       }
     }
-  })();
-}
+  }
 
-function findCurrentFiberUsingSlowPath(fiber) {
-  var alternate = fiber.alternate;
+  function findCurrentFiberUsingSlowPath(fiber) {
+    var alternate = fiber.alternate;
 
-  if (!alternate) {
-    // If there is no alternate, then we only need to check if it is mounted.
-    var nearestMounted = getNearestMountedFiber(fiber);
+    if (!alternate) {
+      // If there is no alternate, then we only need to check if it is mounted.
+      var nearestMounted = getNearestMountedFiber(fiber);
 
-    (function () {
       if (!(nearestMounted !== null)) {
         {
-          throw ReactError(Error("Unable to find node on an unmounted component."));
+          throw Error( "Unable to find node on an unmounted component." );
         }
       }
-    })();
 
-    if (nearestMounted !== fiber) {
-      return null;
-    }
+      if (nearestMounted !== fiber) {
+        return null;
+      }
 
-    return fiber;
-  } // If we have two possible branches, we'll walk backwards up to the root
-  // to see what path the root points to. On the way we may hit one of the
-  // special cases and we'll deal with them.
+      return fiber;
+    } // If we have two possible branches, we'll walk backwards up to the root
+    // to see what path the root points to. On the way we may hit one of the
+    // special cases and we'll deal with them.
 
 
-  var a = fiber;
-  var b = alternate;
+    var a = fiber;
+    var b = alternate;
 
-  while (true) {
-    var parentA = a.return;
+    while (true) {
+      var parentA = a.return;
 
-    if (parentA === null) {
-      // We're at the root.
-      break;
-    }
+      if (parentA === null) {
+        // We're at the root.
+        break;
+      }
 
-    var parentB = parentA.alternate;
+      var parentB = parentA.alternate;
 
-    if (parentB === null) {
-      // There is no alternate. This is an unusual case. Currently, it only
-      // happens when a Suspense component is hidden. An extra fragment fiber
-      // is inserted in between the Suspense fiber and its children. Skip
-      // over this extra fragment fiber and proceed to the next parent.
-      var nextParent = parentA.return;
+      if (parentB === null) {
+        // There is no alternate. This is an unusual case. Currently, it only
+        // happens when a Suspense component is hidden. An extra fragment fiber
+        // is inserted in between the Suspense fiber and its children. Skip
+        // over this extra fragment fiber and proceed to the next parent.
+        var nextParent = parentA.return;
 
-      if (nextParent !== null) {
-        a = b = nextParent;
-        continue;
-      } // If there's no parent, we're at the root.
+        if (nextParent !== null) {
+          a = b = nextParent;
+          continue;
+        } // If there's no parent, we're at the root.
 
 
-      break;
-    } // If both copies of the parent fiber point to the same child, we can
-    // assume that the child is current. This happens when we bailout on low
-    // priority: the bailed out fiber's child reuses the current child.
+        break;
+      } // If both copies of the parent fiber point to the same child, we can
+      // assume that the child is current. This happens when we bailout on low
+      // priority: the bailed out fiber's child reuses the current child.
 
 
-    if (parentA.child === parentB.child) {
-      var child = parentA.child;
+      if (parentA.child === parentB.child) {
+        var child = parentA.child;
 
-      while (child) {
-        if (child === a) {
-          // We've determined that A is the current branch.
-          assertIsMounted(parentA);
-          return fiber;
-        }
+        while (child) {
+          if (child === a) {
+            // We've determined that A is the current branch.
+            assertIsMounted(parentA);
+            return fiber;
+          }
 
-        if (child === b) {
-          // We've determined that B is the current branch.
-          assertIsMounted(parentA);
-          return alternate;
-        }
+          if (child === b) {
+            // We've determined that B is the current branch.
+            assertIsMounted(parentA);
+            return alternate;
+          }
 
-        child = child.sibling;
-      } // We should never have an alternate for any mounting node. So the only
-      // way this could possibly happen is if this was unmounted, if at all.
+          child = child.sibling;
+        } // We should never have an alternate for any mounting node. So the only
+        // way this could possibly happen is if this was unmounted, if at all.
 
 
-      (function () {
         {
           {
-            throw ReactError(Error("Unable to find node on an unmounted component."));
+            throw Error( "Unable to find node on an unmounted component." );
           }
         }
-      })();
-    }
-
-    if (a.return !== b.return) {
-      // The return pointer of A and the return pointer of B point to different
-      // fibers. We assume that return pointers never criss-cross, so A must
-      // belong to the child set of A.return, and B must belong to the child
-      // set of B.return.
-      a = parentA;
-      b = parentB;
-    } else {
-      // The return pointers point to the same fiber. We'll have to use the
-      // default, slow path: scan the child sets of each parent alternate to see
-      // which child belongs to which set.
-      //
-      // Search parent A's child set
-      var didFindChild = false;
-      var _child = parentA.child;
-
-      while (_child) {
-        if (_child === a) {
-          didFindChild = true;
-          a = parentA;
-          b = parentB;
-          break;
-        }
-
-        if (_child === b) {
-          didFindChild = true;
-          b = parentA;
-          a = parentB;
-          break;
-        }
-
-        _child = _child.sibling;
       }
 
-      if (!didFindChild) {
-        // Search parent B's child set
-        _child = parentB.child;
+      if (a.return !== b.return) {
+        // The return pointer of A and the return pointer of B point to different
+        // fibers. We assume that return pointers never criss-cross, so A must
+        // belong to the child set of A.return, and B must belong to the child
+        // set of B.return.
+        a = parentA;
+        b = parentB;
+      } else {
+        // The return pointers point to the same fiber. We'll have to use the
+        // default, slow path: scan the child sets of each parent alternate to see
+        // which child belongs to which set.
+        //
+        // Search parent A's child set
+        var didFindChild = false;
+        var _child = parentA.child;
 
         while (_child) {
           if (_child === a) {
             didFindChild = true;
-            a = parentB;
-            b = parentA;
+            a = parentA;
+            b = parentB;
             break;
           }
 
           if (_child === b) {
             didFindChild = true;
-            b = parentB;
-            a = parentA;
+            b = parentA;
+            a = parentB;
             break;
           }
 
           _child = _child.sibling;
         }
 
-        (function () {
+        if (!didFindChild) {
+          // Search parent B's child set
+          _child = parentB.child;
+
+          while (_child) {
+            if (_child === a) {
+              didFindChild = true;
+              a = parentB;
+              b = parentA;
+              break;
+            }
+
+            if (_child === b) {
+              didFindChild = true;
+              b = parentB;
+              a = parentA;
+              break;
+            }
+
+            _child = _child.sibling;
+          }
+
           if (!didFindChild) {
             {
-              throw ReactError(Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."));
+              throw Error( "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue." );
             }
           }
-        })();
+        }
       }
-    }
 
-    (function () {
       if (!(a.alternate === b)) {
         {
-          throw ReactError(Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."));
+          throw Error( "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue." );
         }
       }
-    })();
-  } // If the root is not a host container, we're in a disconnected tree. I.e.
-  // unmounted.
+    } // If the root is not a host container, we're in a disconnected tree. I.e.
+    // unmounted.
 
 
-  (function () {
     if (!(a.tag === HostRoot)) {
       {
-        throw ReactError(Error("Unable to find node on an unmounted component."));
+        throw Error( "Unable to find node on an unmounted component." );
       }
     }
-  })();
-
-  if (a.stateNode.current === a) {
-    // We've determined that A is the current branch.
-    return fiber;
-  } // Otherwise B has to be current branch.
 
+    if (a.stateNode.current === a) {
+      // We've determined that A is the current branch.
+      return fiber;
+    } // Otherwise B has to be current branch.
 
-  return alternate;
-}
 
-/* eslint valid-typeof: 0 */
-var EVENT_POOL_SIZE = 10;
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+    return alternate;
+  }
 
-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.
- */
+  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 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;
+  function functionThatReturnsTrue() {
+    return true;
   }
 
-  this.dispatchConfig = dispatchConfig;
-  this._targetInst = targetInst;
-  this.nativeEvent = nativeEvent;
-  var Interface = this.constructor.Interface;
+  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.
+   */
 
-  for (var propName in Interface) {
-    if (!Interface.hasOwnProperty(propName)) {
-      continue;
-    }
 
+  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
     {
-      delete this[propName]; // this has a getter/setter for warnings
+      // these have a getter/setter for warnings
+      delete this.nativeEvent;
+      delete this.preventDefault;
+      delete this.stopPropagation;
+      delete this.isDefaultPrevented;
+      delete this.isPropagationStopped;
     }
 
-    var normalize = Interface[propName];
+    this.dispatchConfig = dispatchConfig;
+    this._targetInst = targetInst;
+    this.nativeEvent = nativeEvent;
+    var Interface = this.constructor.Interface;
 
-    if (normalize) {
-      this[propName] = normalize(nativeEvent);
-    } else {
-      if (propName === 'target') {
-        this.target = nativeEventTarget;
+    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 {
-        this[propName] = nativeEvent[propName];
+        if (propName === 'target') {
+          this.target = nativeEventTarget;
+        } else {
+          this[propName] = nativeEvent[propName];
+        }
       }
     }
-  }
 
-  var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+    var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
 
-  if (defaultPrevented) {
-    this.isDefaultPrevented = functionThatReturnsTrue;
-  } else {
-    this.isDefaultPrevented = functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
   }
 
-  this.isPropagationStopped = functionThatReturnsFalse;
-  return this;
-}
+  _assign(SyntheticEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      var event = this.nativeEvent;
 
-_assign(SyntheticEvent.prototype, {
-  preventDefault: function () {
-    this.defaultPrevented = true;
-    var event = this.nativeEvent;
+      if (!event) {
+        return;
+      }
 
-    if (!event) {
-      return;
-    }
+      if (event.preventDefault) {
+        event.preventDefault();
+      } else if (typeof event.returnValue !== 'unknown') {
+        event.returnValue = false;
+      }
 
-    if (event.preventDefault) {
-      event.preventDefault();
-    } else if (typeof event.returnValue !== 'unknown') {
-      event.returnValue = false;
-    }
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
 
-    this.isDefaultPrevented = functionThatReturnsTrue;
-  },
-  stopPropagation: function () {
-    var event = this.nativeEvent;
+      if (!event) {
+        return;
+      }
 
-    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;
+      }
 
-    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;
+    },
 
-    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;
+    },
 
-  /**
-   * 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,
 
-  /**
-   * 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;
 
-  /**
-   * `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;
 
-    for (var propName in Interface) {
       {
-        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+        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 () {}));
       }
     }
+  });
 
-    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.Interface = EventInterface;
-/**
- * Helper to reduce boilerplate when creating subclasses.
- */
+  SyntheticEvent.extend = function (Interface) {
+    var Super = this;
 
-SyntheticEvent.extend = function (Interface) {
-  var Super = this;
+    var E = function () {};
 
-  var E = function () {};
+    E.prototype = Super.prototype;
+    var prototype = new E();
 
-  E.prototype = Super.prototype;
-  var prototype = new E();
+    function Class() {
+      return Super.apply(this, arguments);
+    }
 
-  function Class() {
-    return Super.apply(this, arguments);
-  }
+    _assign(prototype, Class.prototype);
 
-  _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;
+  };
 
-  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
+   */
 
-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 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 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 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 warn(action, result) {
-    var warningCondition = false;
-    !warningCondition ? warningWithoutStack$1(false, "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) : void 0;
-  }
-}
+  function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+    var EventConstructor = this;
 
-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;
+    }
 
-  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);
   }
 
-  return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
-}
+  function releasePooledEvent(event) {
+    var EventConstructor = this;
 
-function releasePooledEvent(event) {
-  var EventConstructor = this;
-
-  (function () {
     if (!(event instanceof EventConstructor)) {
       {
-        throw ReactError(Error("Trying to release an event instance into a pool of a different type."));
+        throw Error( "Trying to release an event instance into a pool of a different type." );
       }
     }
-  })();
 
-  event.destructor();
+    event.destructor();
 
-  if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
-    EventConstructor.eventPool.push(event);
+    if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
+      EventConstructor.eventPool.push(event);
+    }
   }
-}
 
-function addEventPoolingTo(EventConstructor) {
-  EventConstructor.eventPool = [];
-  EventConstructor.getPooled = getPooledEvent;
-  EventConstructor.release = releasePooledEvent;
-}
-
-/**
- * Forked from fbjs/warning:
- * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
- *
- * Only change is we use console.warn instead of console.error,
- * and do nothing when 'console' is not supported.
- * This really simplifies the code.
- * ---
- * Similar to invariant but only logs a warning if the condition is not met.
- * This can be used to log issues in development environments in critical
- * paths. Removing the logging code for production environments will keep the
- * same logic and follow the same code paths.
- */
-var lowPriorityWarningWithoutStack = function () {};
+  function addEventPoolingTo(EventConstructor) {
+    EventConstructor.eventPool = [];
+    EventConstructor.getPooled = getPooledEvent;
+    EventConstructor.release = releasePooledEvent;
+  }
 
-{
-  var printWarning = function (format) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
+  /**
+   * HTML nodeType values that represent the type of the node
+   */
+  var ELEMENT_NODE = 1;
 
-    var argIndex = 0;
-    var message = 'Warning: ' + format.replace(/%s/g, function () {
-      return args[argIndex++];
-    });
+  // Do not use the below two methods directly!
+  // Instead use constants exported from DOMTopLevelEventTypes in ReactDOM.
+  // (It is the only module that is allowed to access these methods.)
+  function unsafeCastStringToDOMTopLevelType(topLevelType) {
+    return topLevelType;
+  }
 
-    if (typeof console !== 'undefined') {
-      console.warn(message);
-    }
+  var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
 
-    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.
-      throw new Error(message);
-    } catch (x) {}
-  };
+  /**
+   * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+   *
+   * @param {string} styleProp
+   * @param {string} eventName
+   * @returns {object}
+   */
 
-  lowPriorityWarningWithoutStack = function (condition, format) {
-    if (format === undefined) {
-      throw new Error('`lowPriorityWarningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
-    }
+  function makePrefixMap(styleProp, eventName) {
+    var prefixes = {};
+    prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+    prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+    prefixes['Moz' + styleProp] = 'moz' + eventName;
+    return prefixes;
+  }
+  /**
+   * A list of event names to a configurable list of vendor prefixes.
+   */
 
-    if (!condition) {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-        args[_key2 - 2] = arguments[_key2];
-      }
 
-      printWarning.apply(void 0, [format].concat(args));
-    }
+  var vendorPrefixes = {
+    animationend: makePrefixMap('Animation', 'AnimationEnd'),
+    animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+    animationstart: makePrefixMap('Animation', 'AnimationStart'),
+    transitionend: makePrefixMap('Transition', 'TransitionEnd')
   };
-}
-
-var lowPriorityWarningWithoutStack$1 = lowPriorityWarningWithoutStack;
-
-/**
- * HTML nodeType values that represent the type of the node
- */
-var ELEMENT_NODE = 1;
-
-// Do not use the below two methods directly!
-// Instead use constants exported from DOMTopLevelEventTypes in ReactDOM.
-// (It is the only module that is allowed to access these methods.)
-function unsafeCastStringToDOMTopLevelType(topLevelType) {
-  return topLevelType;
-}
+  /**
+   * Event names that have already been detected and prefixed (if applicable).
+   */
 
-var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+  var prefixedEventNames = {};
+  /**
+   * Element to check for prefixes on.
+   */
 
-/**
- * Generate a mapping of standard vendor prefixes using the defined style property and event name.
- *
- * @param {string} styleProp
- * @param {string} eventName
- * @returns {object}
- */
+  var style = {};
+  /**
+   * Bootstrap if a DOM exists.
+   */
 
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
-  prefixes['Moz' + styleProp] = 'moz' + eventName;
-  return prefixes;
-}
-/**
- * A list of event names to a configurable list of vendor prefixes.
- */
+  if (canUseDOM) {
+    style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
+    // the un-prefixed "animation" and "transition" properties are defined on the
+    // style object but the events that fire will still be prefixed, so we need
+    // to check if the un-prefixed events are usable, and if not remove them from the map.
 
+    if (!('AnimationEvent' in window)) {
+      delete vendorPrefixes.animationend.animation;
+      delete vendorPrefixes.animationiteration.animation;
+      delete vendorPrefixes.animationstart.animation;
+    } // Same as above
 
-var vendorPrefixes = {
-  animationend: makePrefixMap('Animation', 'AnimationEnd'),
-  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
-  animationstart: makePrefixMap('Animation', 'AnimationStart'),
-  transitionend: makePrefixMap('Transition', 'TransitionEnd')
-};
-/**
- * Event names that have already been detected and prefixed (if applicable).
- */
 
-var prefixedEventNames = {};
-/**
- * Element to check for prefixes on.
- */
+    if (!('TransitionEvent' in window)) {
+      delete vendorPrefixes.transitionend.transition;
+    }
+  }
+  /**
+   * Attempts to determine the correct vendor prefixed event name.
+   *
+   * @param {string} eventName
+   * @returns {string}
+   */
 
-var style = {};
-/**
- * Bootstrap if a DOM exists.
- */
 
-if (canUseDOM) {
-  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
-  // the un-prefixed "animation" and "transition" properties are defined on the
-  // style object but the events that fire will still be prefixed, so we need
-  // to check if the un-prefixed events are usable, and if not remove them from the map.
+  function getVendorPrefixedEventName(eventName) {
+    if (prefixedEventNames[eventName]) {
+      return prefixedEventNames[eventName];
+    } else if (!vendorPrefixes[eventName]) {
+      return eventName;
+    }
 
-  if (!('AnimationEvent' in window)) {
-    delete vendorPrefixes.animationend.animation;
-    delete vendorPrefixes.animationiteration.animation;
-    delete vendorPrefixes.animationstart.animation;
-  } // Same as above
+    var prefixMap = vendorPrefixes[eventName];
 
+    for (var styleProp in prefixMap) {
+      if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+        return prefixedEventNames[eventName] = prefixMap[styleProp];
+      }
+    }
 
-  if (!('TransitionEvent' in window)) {
-    delete vendorPrefixes.transitionend.transition;
+    return eventName;
   }
-}
-/**
- * Attempts to determine the correct vendor prefixed event name.
- *
- * @param {string} eventName
- * @returns {string}
- */
 
+  /**
+   * To identify top level events in ReactDOM, we use constants defined by this
+   * module. This is the only module that uses the unsafe* methods to express
+   * that the constants actually correspond to the browser event names. This lets
+   * us save some bundle size by avoiding a top level type -> event name map.
+   * The rest of ReactDOM code should import top level types from this file.
+   */
 
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) {
-    return prefixedEventNames[eventName];
-  } else if (!vendorPrefixes[eventName]) {
-    return eventName;
-  }
+  var TOP_ABORT = unsafeCastStringToDOMTopLevelType('abort');
+  var TOP_ANIMATION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationend'));
+  var TOP_ANIMATION_ITERATION = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationiteration'));
+  var TOP_ANIMATION_START = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationstart'));
+  var TOP_BLUR = unsafeCastStringToDOMTopLevelType('blur');
+  var TOP_CAN_PLAY = unsafeCastStringToDOMTopLevelType('canplay');
+  var TOP_CAN_PLAY_THROUGH = unsafeCastStringToDOMTopLevelType('canplaythrough');
+  var TOP_CANCEL = unsafeCastStringToDOMTopLevelType('cancel');
+  var TOP_CHANGE = unsafeCastStringToDOMTopLevelType('change');
+  var TOP_CLICK = unsafeCastStringToDOMTopLevelType('click');
+  var TOP_CLOSE = unsafeCastStringToDOMTopLevelType('close');
+  var TOP_COMPOSITION_END = unsafeCastStringToDOMTopLevelType('compositionend');
+  var TOP_COMPOSITION_START = unsafeCastStringToDOMTopLevelType('compositionstart');
+  var TOP_COMPOSITION_UPDATE = unsafeCastStringToDOMTopLevelType('compositionupdate');
+  var TOP_CONTEXT_MENU = unsafeCastStringToDOMTopLevelType('contextmenu');
+  var TOP_COPY = unsafeCastStringToDOMTopLevelType('copy');
+  var TOP_CUT = unsafeCastStringToDOMTopLevelType('cut');
+  var TOP_DOUBLE_CLICK = unsafeCastStringToDOMTopLevelType('dblclick');
+  var TOP_DRAG = unsafeCastStringToDOMTopLevelType('drag');
+  var TOP_DRAG_END = unsafeCastStringToDOMTopLevelType('dragend');
+  var TOP_DRAG_ENTER = unsafeCastStringToDOMTopLevelType('dragenter');
+  var TOP_DRAG_EXIT = unsafeCastStringToDOMTopLevelType('dragexit');
+  var TOP_DRAG_LEAVE = unsafeCastStringToDOMTopLevelType('dragleave');
+  var TOP_DRAG_OVER = unsafeCastStringToDOMTopLevelType('dragover');
+  var TOP_DRAG_START = unsafeCastStringToDOMTopLevelType('dragstart');
+  var TOP_DROP = unsafeCastStringToDOMTopLevelType('drop');
+  var TOP_DURATION_CHANGE = unsafeCastStringToDOMTopLevelType('durationchange');
+  var TOP_EMPTIED = unsafeCastStringToDOMTopLevelType('emptied');
+  var TOP_ENCRYPTED = unsafeCastStringToDOMTopLevelType('encrypted');
+  var TOP_ENDED = unsafeCastStringToDOMTopLevelType('ended');
+  var TOP_ERROR = unsafeCastStringToDOMTopLevelType('error');
+  var TOP_FOCUS = unsafeCastStringToDOMTopLevelType('focus');
+  var TOP_INPUT = unsafeCastStringToDOMTopLevelType('input');
+  var TOP_KEY_DOWN = unsafeCastStringToDOMTopLevelType('keydown');
+  var TOP_KEY_PRESS = unsafeCastStringToDOMTopLevelType('keypress');
+  var TOP_KEY_UP = unsafeCastStringToDOMTopLevelType('keyup');
+  var TOP_LOAD = unsafeCastStringToDOMTopLevelType('load');
+  var TOP_LOAD_START = unsafeCastStringToDOMTopLevelType('loadstart');
+  var TOP_LOADED_DATA = unsafeCastStringToDOMTopLevelType('loadeddata');
+  var TOP_LOADED_METADATA = unsafeCastStringToDOMTopLevelType('loadedmetadata');
+  var TOP_MOUSE_DOWN = unsafeCastStringToDOMTopLevelType('mousedown');
+  var TOP_MOUSE_MOVE = unsafeCastStringToDOMTopLevelType('mousemove');
+  var TOP_MOUSE_OUT = unsafeCastStringToDOMTopLevelType('mouseout');
+  var TOP_MOUSE_OVER = unsafeCastStringToDOMTopLevelType('mouseover');
+  var TOP_MOUSE_UP = unsafeCastStringToDOMTopLevelType('mouseup');
+  var TOP_PASTE = unsafeCastStringToDOMTopLevelType('paste');
+  var TOP_PAUSE = unsafeCastStringToDOMTopLevelType('pause');
+  var TOP_PLAY = unsafeCastStringToDOMTopLevelType('play');
+  var TOP_PLAYING = unsafeCastStringToDOMTopLevelType('playing');
+  var TOP_PROGRESS = unsafeCastStringToDOMTopLevelType('progress');
+  var TOP_RATE_CHANGE = unsafeCastStringToDOMTopLevelType('ratechange');
+  var TOP_SCROLL = unsafeCastStringToDOMTopLevelType('scroll');
+  var TOP_SEEKED = unsafeCastStringToDOMTopLevelType('seeked');
+  var TOP_SEEKING = unsafeCastStringToDOMTopLevelType('seeking');
+  var TOP_SELECTION_CHANGE = unsafeCastStringToDOMTopLevelType('selectionchange');
+  var TOP_STALLED = unsafeCastStringToDOMTopLevelType('stalled');
+  var TOP_SUSPEND = unsafeCastStringToDOMTopLevelType('suspend');
+  var TOP_TEXT_INPUT = unsafeCastStringToDOMTopLevelType('textInput');
+  var TOP_TIME_UPDATE = unsafeCastStringToDOMTopLevelType('timeupdate');
+  var TOP_TOGGLE = unsafeCastStringToDOMTopLevelType('toggle');
+  var TOP_TOUCH_CANCEL = unsafeCastStringToDOMTopLevelType('touchcancel');
+  var TOP_TOUCH_END = unsafeCastStringToDOMTopLevelType('touchend');
+  var TOP_TOUCH_MOVE = unsafeCastStringToDOMTopLevelType('touchmove');
+  var TOP_TOUCH_START = unsafeCastStringToDOMTopLevelType('touchstart');
+  var TOP_TRANSITION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('transitionend'));
+  var TOP_VOLUME_CHANGE = unsafeCastStringToDOMTopLevelType('volumechange');
+  var TOP_WAITING = unsafeCastStringToDOMTopLevelType('waiting');
+  var TOP_WHEEL = unsafeCastStringToDOMTopLevelType('wheel'); // List of events that need to be individually attached to media elements.
+
+  var PLUGIN_EVENT_SYSTEM = 1;
+
+  var didWarnAboutMessageChannel = false;
+  var enqueueTaskImpl = null;
+  function enqueueTask(task) {
+    if (enqueueTaskImpl === null) {
+      try {
+        // read require off the module object to get around the bundlers.
+        // we don't want them to detect a require and bundle a Node polyfill.
+        var requireString = ('require' + Math.random()).slice(0, 7);
+        var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
+        // version of setImmediate, bypassing fake timers if any.
+
+        enqueueTaskImpl = nodeRequire('timers').setImmediate;
+      } catch (_err) {
+        // we're in a browser
+        // we can't use regular timers because they may still be faked
+        // so we try MessageChannel+postMessage instead
+        enqueueTaskImpl = function (callback) {
+          {
+            if (didWarnAboutMessageChannel === false) {
+              didWarnAboutMessageChannel = true;
 
-  var prefixMap = vendorPrefixes[eventName];
+              if (typeof MessageChannel === 'undefined') {
+                error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
+              }
+            }
+          }
 
-  for (var styleProp in prefixMap) {
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
-      return prefixedEventNames[eventName] = prefixMap[styleProp];
+          var channel = new MessageChannel();
+          channel.port1.onmessage = callback;
+          channel.port2.postMessage(undefined);
+        };
+      }
     }
+
+    return enqueueTaskImpl(task);
   }
 
-  return eventName;
-}
+  var ReactInternals$1 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  var _ReactInternals$Sched = ReactInternals$1.Scheduler,
+      unstable_cancelCallback = _ReactInternals$Sched.unstable_cancelCallback,
+      unstable_now = _ReactInternals$Sched.unstable_now,
+      unstable_scheduleCallback = _ReactInternals$Sched.unstable_scheduleCallback,
+      unstable_shouldYield = _ReactInternals$Sched.unstable_shouldYield,
+      unstable_requestPaint = _ReactInternals$Sched.unstable_requestPaint,
+      unstable_getFirstCallbackNode = _ReactInternals$Sched.unstable_getFirstCallbackNode,
+      unstable_runWithPriority = _ReactInternals$Sched.unstable_runWithPriority,
+      unstable_next = _ReactInternals$Sched.unstable_next,
+      unstable_continueExecution = _ReactInternals$Sched.unstable_continueExecution,
+      unstable_pauseExecution = _ReactInternals$Sched.unstable_pauseExecution,
+      unstable_getCurrentPriorityLevel = _ReactInternals$Sched.unstable_getCurrentPriorityLevel,
+      unstable_ImmediatePriority = _ReactInternals$Sched.unstable_ImmediatePriority,
+      unstable_UserBlockingPriority = _ReactInternals$Sched.unstable_UserBlockingPriority,
+      unstable_NormalPriority = _ReactInternals$Sched.unstable_NormalPriority,
+      unstable_LowPriority = _ReactInternals$Sched.unstable_LowPriority,
+      unstable_IdlePriority = _ReactInternals$Sched.unstable_IdlePriority,
+      unstable_forceFrameRate = _ReactInternals$Sched.unstable_forceFrameRate,
+      unstable_flushAllWithoutAsserting = _ReactInternals$Sched.unstable_flushAllWithoutAsserting;
+
+  // ReactDOM.js, and ReactTestUtils.js:
+
+  var _ReactDOM$__SECRET_IN = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
+
+  /* eslint-disable no-unused-vars */
+  getInstanceFromNode = _ReactDOM$__SECRET_IN[0],
+      getNodeFromInstance = _ReactDOM$__SECRET_IN[1],
+      getFiberCurrentPropsFromNode = _ReactDOM$__SECRET_IN[2],
+      injectEventPluginsByName = _ReactDOM$__SECRET_IN[3],
+      eventNameDispatchConfigs = _ReactDOM$__SECRET_IN[4],
+      accumulateTwoPhaseDispatches = _ReactDOM$__SECRET_IN[5],
+      accumulateDirectDispatches = _ReactDOM$__SECRET_IN[6],
+      enqueueStateRestore = _ReactDOM$__SECRET_IN[7],
+      restoreStateIfNeeded = _ReactDOM$__SECRET_IN[8],
+      dispatchEvent = _ReactDOM$__SECRET_IN[9],
+      runEventsInBatch = _ReactDOM$__SECRET_IN[10],
+
+  /* eslint-enable no-unused-vars */
+  flushPassiveEffects = _ReactDOM$__SECRET_IN[11],
+      IsThisRendererActing = _ReactDOM$__SECRET_IN[12];
+  var batchedUpdates = ReactDOM.unstable_batchedUpdates;
+  var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing; // this implementation should be exactly the same in
+  // ReactTestUtilsAct.js, ReactTestRendererAct.js, createReactNoop.js
+
+  var isSchedulerMocked = typeof unstable_flushAllWithoutAsserting === 'function';
+
+  var flushWork = unstable_flushAllWithoutAsserting || function () {
+    var didFlushWork = false;
+
+    while (flushPassiveEffects()) {
+      didFlushWork = true;
+    }
 
-/**
- * To identify top level events in ReactDOM, we use constants defined by this
- * module. This is the only module that uses the unsafe* methods to express
- * that the constants actually correspond to the browser event names. This lets
- * us save some bundle size by avoiding a top level type -> event name map.
- * The rest of ReactDOM code should import top level types from this file.
- */
+    return didFlushWork;
+  };
 
-var TOP_ABORT = unsafeCastStringToDOMTopLevelType('abort');
-var TOP_ANIMATION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationend'));
-var TOP_ANIMATION_ITERATION = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationiteration'));
-var TOP_ANIMATION_START = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationstart'));
-var TOP_BLUR = unsafeCastStringToDOMTopLevelType('blur');
-var TOP_CAN_PLAY = unsafeCastStringToDOMTopLevelType('canplay');
-var TOP_CAN_PLAY_THROUGH = unsafeCastStringToDOMTopLevelType('canplaythrough');
-var TOP_CANCEL = unsafeCastStringToDOMTopLevelType('cancel');
-var TOP_CHANGE = unsafeCastStringToDOMTopLevelType('change');
-var TOP_CLICK = unsafeCastStringToDOMTopLevelType('click');
-var TOP_CLOSE = unsafeCastStringToDOMTopLevelType('close');
-var TOP_COMPOSITION_END = unsafeCastStringToDOMTopLevelType('compositionend');
-var TOP_COMPOSITION_START = unsafeCastStringToDOMTopLevelType('compositionstart');
-var TOP_COMPOSITION_UPDATE = unsafeCastStringToDOMTopLevelType('compositionupdate');
-var TOP_CONTEXT_MENU = unsafeCastStringToDOMTopLevelType('contextmenu');
-var TOP_COPY = unsafeCastStringToDOMTopLevelType('copy');
-var TOP_CUT = unsafeCastStringToDOMTopLevelType('cut');
-var TOP_DOUBLE_CLICK = unsafeCastStringToDOMTopLevelType('dblclick');
-
-var TOP_DRAG = unsafeCastStringToDOMTopLevelType('drag');
-var TOP_DRAG_END = unsafeCastStringToDOMTopLevelType('dragend');
-var TOP_DRAG_ENTER = unsafeCastStringToDOMTopLevelType('dragenter');
-var TOP_DRAG_EXIT = unsafeCastStringToDOMTopLevelType('dragexit');
-var TOP_DRAG_LEAVE = unsafeCastStringToDOMTopLevelType('dragleave');
-var TOP_DRAG_OVER = unsafeCastStringToDOMTopLevelType('dragover');
-var TOP_DRAG_START = unsafeCastStringToDOMTopLevelType('dragstart');
-var TOP_DROP = unsafeCastStringToDOMTopLevelType('drop');
-var TOP_DURATION_CHANGE = unsafeCastStringToDOMTopLevelType('durationchange');
-var TOP_EMPTIED = unsafeCastStringToDOMTopLevelType('emptied');
-var TOP_ENCRYPTED = unsafeCastStringToDOMTopLevelType('encrypted');
-var TOP_ENDED = unsafeCastStringToDOMTopLevelType('ended');
-var TOP_ERROR = unsafeCastStringToDOMTopLevelType('error');
-var TOP_FOCUS = unsafeCastStringToDOMTopLevelType('focus');
-
-var TOP_INPUT = unsafeCastStringToDOMTopLevelType('input');
-
-var TOP_KEY_DOWN = unsafeCastStringToDOMTopLevelType('keydown');
-var TOP_KEY_PRESS = unsafeCastStringToDOMTopLevelType('keypress');
-var TOP_KEY_UP = unsafeCastStringToDOMTopLevelType('keyup');
-var TOP_LOAD = unsafeCastStringToDOMTopLevelType('load');
-var TOP_LOAD_START = unsafeCastStringToDOMTopLevelType('loadstart');
-var TOP_LOADED_DATA = unsafeCastStringToDOMTopLevelType('loadeddata');
-var TOP_LOADED_METADATA = unsafeCastStringToDOMTopLevelType('loadedmetadata');
-
-var TOP_MOUSE_DOWN = unsafeCastStringToDOMTopLevelType('mousedown');
-var TOP_MOUSE_MOVE = unsafeCastStringToDOMTopLevelType('mousemove');
-var TOP_MOUSE_OUT = unsafeCastStringToDOMTopLevelType('mouseout');
-var TOP_MOUSE_OVER = unsafeCastStringToDOMTopLevelType('mouseover');
-var TOP_MOUSE_UP = unsafeCastStringToDOMTopLevelType('mouseup');
-var TOP_PASTE = unsafeCastStringToDOMTopLevelType('paste');
-var TOP_PAUSE = unsafeCastStringToDOMTopLevelType('pause');
-var TOP_PLAY = unsafeCastStringToDOMTopLevelType('play');
-var TOP_PLAYING = unsafeCastStringToDOMTopLevelType('playing');
-
-
-
-
-
-
-
-
-var TOP_PROGRESS = unsafeCastStringToDOMTopLevelType('progress');
-var TOP_RATE_CHANGE = unsafeCastStringToDOMTopLevelType('ratechange');
-
-var TOP_SCROLL = unsafeCastStringToDOMTopLevelType('scroll');
-var TOP_SEEKED = unsafeCastStringToDOMTopLevelType('seeked');
-var TOP_SEEKING = unsafeCastStringToDOMTopLevelType('seeking');
-var TOP_SELECTION_CHANGE = unsafeCastStringToDOMTopLevelType('selectionchange');
-var TOP_STALLED = unsafeCastStringToDOMTopLevelType('stalled');
-
-var TOP_SUSPEND = unsafeCastStringToDOMTopLevelType('suspend');
-var TOP_TEXT_INPUT = unsafeCastStringToDOMTopLevelType('textInput');
-var TOP_TIME_UPDATE = unsafeCastStringToDOMTopLevelType('timeupdate');
-var TOP_TOGGLE = unsafeCastStringToDOMTopLevelType('toggle');
-var TOP_TOUCH_CANCEL = unsafeCastStringToDOMTopLevelType('touchcancel');
-var TOP_TOUCH_END = unsafeCastStringToDOMTopLevelType('touchend');
-var TOP_TOUCH_MOVE = unsafeCastStringToDOMTopLevelType('touchmove');
-var TOP_TOUCH_START = unsafeCastStringToDOMTopLevelType('touchstart');
-var TOP_TRANSITION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('transitionend'));
-var TOP_VOLUME_CHANGE = unsafeCastStringToDOMTopLevelType('volumechange');
-var TOP_WAITING = unsafeCastStringToDOMTopLevelType('waiting');
-var TOP_WHEEL = unsafeCastStringToDOMTopLevelType('wheel'); // List of events that need to be individually attached to media elements.
-// Note that events in this list will *not* be listened to at the top level
-// unless they're explicitly whitelisted in `ReactBrowserEventEmitter.listenTo`.
-
-var PLUGIN_EVENT_SYSTEM = 1;
-
-var didWarnAboutMessageChannel = false;
-var enqueueTask;
-
-try {
-  // read require off the module object to get around the bundlers.
-  // we don't want them to detect a require and bundle a Node polyfill.
-  var requireString = ('require' + Math.random()).slice(0, 7);
-  var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
-  // version of setImmediate, bypassing fake timers if any.
-
-  enqueueTask = nodeRequire('timers').setImmediate;
-} catch (_err) {
-  // we're in a browser
-  // we can't use regular timers because they may still be faked
-  // so we try MessageChannel+postMessage instead
-  enqueueTask = function (callback) {
-    {
-      if (didWarnAboutMessageChannel === false) {
-        didWarnAboutMessageChannel = true;
-        !(typeof MessageChannel !== 'undefined') ? warningWithoutStack$1(false, 'This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.') : void 0;
-      }
+  function flushWorkAndMicroTasks(onDone) {
+    try {
+      flushWork();
+      enqueueTask(function () {
+        if (flushWork()) {
+          flushWorkAndMicroTasks(onDone);
+        } else {
+          onDone();
+        }
+      });
+    } catch (err) {
+      onDone(err);
     }
+  } // we track the 'depth' of the act() calls with this counter,
+  // so we can tell if any async act() calls try to run in parallel.
 
-    var channel = new MessageChannel();
-    channel.port1.onmessage = callback;
-    channel.port2.postMessage(undefined);
-  };
-}
-
-var enqueueTask$1 = enqueueTask;
-
-var ReactInternals$1 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-var _ReactInternals$Sched = ReactInternals$1.Scheduler;
-var unstable_cancelCallback = _ReactInternals$Sched.unstable_cancelCallback;
-var unstable_now = _ReactInternals$Sched.unstable_now;
-var unstable_scheduleCallback = _ReactInternals$Sched.unstable_scheduleCallback;
-var unstable_shouldYield = _ReactInternals$Sched.unstable_shouldYield;
-var unstable_requestPaint = _ReactInternals$Sched.unstable_requestPaint;
-var unstable_getFirstCallbackNode = _ReactInternals$Sched.unstable_getFirstCallbackNode;
-var unstable_runWithPriority = _ReactInternals$Sched.unstable_runWithPriority;
-var unstable_next = _ReactInternals$Sched.unstable_next;
-var unstable_continueExecution = _ReactInternals$Sched.unstable_continueExecution;
-var unstable_pauseExecution = _ReactInternals$Sched.unstable_pauseExecution;
-var unstable_getCurrentPriorityLevel = _ReactInternals$Sched.unstable_getCurrentPriorityLevel;
-var unstable_ImmediatePriority = _ReactInternals$Sched.unstable_ImmediatePriority;
-var unstable_UserBlockingPriority = _ReactInternals$Sched.unstable_UserBlockingPriority;
-var unstable_NormalPriority = _ReactInternals$Sched.unstable_NormalPriority;
-var unstable_LowPriority = _ReactInternals$Sched.unstable_LowPriority;
-var unstable_IdlePriority = _ReactInternals$Sched.unstable_IdlePriority;
-var unstable_forceFrameRate = _ReactInternals$Sched.unstable_forceFrameRate;
-var unstable_flushAllWithoutAsserting = _ReactInternals$Sched.unstable_flushAllWithoutAsserting;
-
-// ReactDOM.js, and ReactTestUtils.js:
-
-var _ReactDOM$__SECRET_IN$1 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
-var getInstanceFromNode$1 = _ReactDOM$__SECRET_IN$1[0];
-var getNodeFromInstance$1 = _ReactDOM$__SECRET_IN$1[1];
-var getFiberCurrentPropsFromNode$1 = _ReactDOM$__SECRET_IN$1[2];
-var injectEventPluginsByName$1 = _ReactDOM$__SECRET_IN$1[3];
-var eventNameDispatchConfigs$1 = _ReactDOM$__SECRET_IN$1[4];
-var accumulateTwoPhaseDispatches$1 = _ReactDOM$__SECRET_IN$1[5];
-var accumulateDirectDispatches$1 = _ReactDOM$__SECRET_IN$1[6];
-var enqueueStateRestore$1 = _ReactDOM$__SECRET_IN$1[7];
-var restoreStateIfNeeded$1 = _ReactDOM$__SECRET_IN$1[8];
-var dispatchEvent$1 = _ReactDOM$__SECRET_IN$1[9];
-var runEventsInBatch$1 = _ReactDOM$__SECRET_IN$1[10];
-var flushPassiveEffects$1 = _ReactDOM$__SECRET_IN$1[11];
-var IsThisRendererActing$1 = _ReactDOM$__SECRET_IN$1[12];
-var batchedUpdates = ReactDOM.unstable_batchedUpdates;
-var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing; // this implementation should be exactly the same in
-// ReactTestUtilsAct.js, ReactTestRendererAct.js, createReactNoop.js
-
-var isSchedulerMocked = typeof unstable_flushAllWithoutAsserting === 'function';
-
-var flushWork = unstable_flushAllWithoutAsserting || function () {
-  var didFlushWork = false;
-
-  while (flushPassiveEffects$1()) {
-    didFlushWork = true;
-  }
 
-  return didFlushWork;
-};
+  var actingUpdatesScopeDepth = 0;
 
-function flushWorkAndMicroTasks(onDone) {
-  try {
-    flushWork();
-    enqueueTask$1(function () {
-      if (flushWork()) {
-        flushWorkAndMicroTasks(onDone);
-      } else {
-        onDone();
-      }
-    });
-  } catch (err) {
-    onDone(err);
-  }
-} // we track the 'depth' of the act() calls with this counter,
-// so we can tell if any async act() calls try to run in parallel.
-
-
-var actingUpdatesScopeDepth = 0;
-function act(callback) {
-  var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
-  var previousIsSomeRendererActing;
-  var previousIsThisRendererActing;
-  actingUpdatesScopeDepth++;
-  previousIsSomeRendererActing = IsSomeRendererActing.current;
-  previousIsThisRendererActing = IsThisRendererActing$1.current;
-  IsSomeRendererActing.current = true;
-  IsThisRendererActing$1.current = true;
-
-  function onDone() {
-    actingUpdatesScopeDepth--;
-    IsSomeRendererActing.current = previousIsSomeRendererActing;
-    IsThisRendererActing$1.current = previousIsThisRendererActing;
+  function act(callback) {
 
-    {
-      if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
-        // if it's _less than_ previousActingUpdatesScopeDepth, then we can assume the 'other' one has warned
-        warningWithoutStack$1(false, 'You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
+    var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
+    var previousIsSomeRendererActing;
+    var previousIsThisRendererActing;
+    actingUpdatesScopeDepth++;
+    previousIsSomeRendererActing = IsSomeRendererActing.current;
+    previousIsThisRendererActing = IsThisRendererActing.current;
+    IsSomeRendererActing.current = true;
+    IsThisRendererActing.current = true;
+
+    function onDone() {
+      actingUpdatesScopeDepth--;
+      IsSomeRendererActing.current = previousIsSomeRendererActing;
+      IsThisRendererActing.current = previousIsThisRendererActing;
+
+      {
+        if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
+          // if it's _less than_ previousActingUpdatesScopeDepth, then we can assume the 'other' one has warned
+          error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
+        }
       }
     }
-  }
 
-  var result;
+    var result;
 
-  try {
-    result = batchedUpdates(callback);
-  } catch (error) {
-    // on sync errors, we still want to 'cleanup' and decrement actingUpdatesScopeDepth
-    onDone();
-    throw error;
-  }
+    try {
+      result = batchedUpdates(callback);
+    } catch (error) {
+      // on sync errors, we still want to 'cleanup' and decrement actingUpdatesScopeDepth
+      onDone();
+      throw error;
+    }
 
-  if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-    // setup a boolean that gets set to true only
-    // once this act() call is await-ed
-    var called = false;
+    if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+      // setup a boolean that gets set to true only
+      // once this act() call is await-ed
+      var called = false;
 
-    {
-      if (typeof Promise !== 'undefined') {
-        //eslint-disable-next-line no-undef
-        Promise.resolve().then(function () {}).then(function () {
-          if (called === false) {
-            warningWithoutStack$1(false, 'You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, interleaving multiple act ' + 'calls and mixing their scopes. You should - await act(async () => ...);');
-          }
-        });
-      }
-    } // in the async case, the returned thenable runs the callback, flushes
-    // effects and  microtasks in a loop until flushPassiveEffects() === false,
-    // and cleans up
+      {
+        if (typeof Promise !== 'undefined') {
+          //eslint-disable-next-line no-undef
+          Promise.resolve().then(function () {}).then(function () {
+            if (called === false) {
+              error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, interleaving multiple act ' + 'calls and mixing their scopes. You should - await act(async () => ...);');
+            }
+          });
+        }
+      } // in the async case, the returned thenable runs the callback, flushes
+      // effects and  microtasks in a loop until flushPassiveEffects() === false,
+      // and cleans up
 
 
-    return {
-      then: function (resolve, reject) {
-        called = true;
-        result.then(function () {
-          if (actingUpdatesScopeDepth > 1 || isSchedulerMocked === true && previousIsSomeRendererActing === true) {
-            onDone();
-            resolve();
-            return;
-          } // we're about to exit the act() scope,
-          // now's the time to flush tasks/effects
+      return {
+        then: function (resolve, reject) {
+          called = true;
+          result.then(function () {
+            if (actingUpdatesScopeDepth > 1 || isSchedulerMocked === true && previousIsSomeRendererActing === true) {
+              onDone();
+              resolve();
+              return;
+            } // we're about to exit the act() scope,
+            // now's the time to flush tasks/effects
 
 
-          flushWorkAndMicroTasks(function (err) {
-            onDone();
+            flushWorkAndMicroTasks(function (err) {
+              onDone();
 
-            if (err) {
-              reject(err);
-            } else {
-              resolve();
-            }
+              if (err) {
+                reject(err);
+              } else {
+                resolve();
+              }
+            });
+          }, function (err) {
+            onDone();
+            reject(err);
           });
-        }, function (err) {
-          onDone();
-          reject(err);
-        });
-      }
-    };
-  } else {
-    {
-      !(result === undefined) ? warningWithoutStack$1(false, 'The callback passed to act(...) function ' + 'must return undefined, or a Promise. You returned %s', result) : void 0;
-    } // flush effects until none remain, and cleanup
+        }
+      };
+    } else {
+      {
+        if (result !== undefined) {
+          error('The callback passed to act(...) function ' + 'must return undefined, or a Promise. You returned %s', result);
+        }
+      } // flush effects until none remain, and cleanup
 
 
-    try {
-      if (actingUpdatesScopeDepth === 1 && (isSchedulerMocked === false || previousIsSomeRendererActing === false)) {
-        // we're about to exit the act() scope,
-        // now's the time to flush effects
-        flushWork();
-      }
+      try {
+        if (actingUpdatesScopeDepth === 1 && (isSchedulerMocked === false || previousIsSomeRendererActing === false)) {
+          // we're about to exit the act() scope,
+          // now's the time to flush effects
+          flushWork();
+        }
 
-      onDone();
-    } catch (err) {
-      onDone();
-      throw err;
-    } // in the sync case, the returned thenable only warns *if* await-ed
+        onDone();
+      } catch (err) {
+        onDone();
+        throw err;
+      } // in the sync case, the returned thenable only warns *if* await-ed
 
 
-    return {
-      then: function (resolve) {
-        {
-          warningWithoutStack$1(false, 'Do not await the result of calling act(...) with sync logic, it is not a Promise.');
-        }
+      return {
+        then: function (resolve) {
+          {
+            error('Do not await the result of calling act(...) with sync logic, it is not a Promise.');
+          }
 
-        resolve();
-      }
-    };
+          resolve();
+        }
+      };
+    }
   }
-}
-
-var findDOMNode = ReactDOM.findDOMNode; // Keep in sync with ReactDOMUnstableNativeDependencies.js
-// ReactDOM.js, and ReactTestUtilsAct.js:
-
-var _ReactDOM$__SECRET_IN = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
-var getInstanceFromNode = _ReactDOM$__SECRET_IN[0];
-var getNodeFromInstance = _ReactDOM$__SECRET_IN[1];
-var getFiberCurrentPropsFromNode = _ReactDOM$__SECRET_IN[2];
-var injectEventPluginsByName = _ReactDOM$__SECRET_IN[3];
-var eventNameDispatchConfigs = _ReactDOM$__SECRET_IN[4];
-var accumulateTwoPhaseDispatches = _ReactDOM$__SECRET_IN[5];
-var accumulateDirectDispatches = _ReactDOM$__SECRET_IN[6];
-var enqueueStateRestore = _ReactDOM$__SECRET_IN[7];
-var restoreStateIfNeeded = _ReactDOM$__SECRET_IN[8];
-var dispatchEvent = _ReactDOM$__SECRET_IN[9];
-var runEventsInBatch = _ReactDOM$__SECRET_IN[10];
-var flushPassiveEffects = _ReactDOM$__SECRET_IN[11];
-var IsThisRendererActing = _ReactDOM$__SECRET_IN[12];
-
-function Event(suffix) {}
-
-var hasWarnedAboutDeprecatedMockComponent = false;
-/**
- * @class ReactTestUtils
- */
 
-/**
- * Simulates a top level event being dispatched from a raw event that occurred
- * on an `Element` node.
- * @param {number} topLevelType A number from `TopLevelEventTypes`
- * @param {!Element} node The dom to simulate an event occurring on.
- * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
- */
+  var findDOMNode = ReactDOM.findDOMNode; // Keep in sync with ReactDOMUnstableNativeDependencies.js
+  // ReactDOM.js, and ReactTestUtilsAct.js:
 
-function simulateNativeEventOnNode(topLevelType, node, fakeNativeEvent) {
-  fakeNativeEvent.target = node;
-  dispatchEvent(topLevelType, PLUGIN_EVENT_SYSTEM, fakeNativeEvent);
-}
-/**
- * Simulates a top level event being dispatched from a raw event that occurred
- * on the `ReactDOMComponent` `comp`.
- * @param {Object} topLevelType A type from `BrowserEventConstants.topLevelTypes`.
- * @param {!ReactDOMComponent} comp
- * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
- */
+  var _ReactDOM$__SECRET_IN$1 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
+      getInstanceFromNode$1 = _ReactDOM$__SECRET_IN$1[0],
 
+  /* eslint-disable no-unused-vars */
+  getNodeFromInstance$1 = _ReactDOM$__SECRET_IN$1[1],
+      getFiberCurrentPropsFromNode$1 = _ReactDOM$__SECRET_IN$1[2],
+      injectEventPluginsByName$1 = _ReactDOM$__SECRET_IN$1[3],
 
-function simulateNativeEventOnDOMComponent(topLevelType, comp, fakeNativeEvent) {
-  simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent);
-}
+  /* eslint-enable no-unused-vars */
+  eventNameDispatchConfigs$1 = _ReactDOM$__SECRET_IN$1[4],
+      accumulateTwoPhaseDispatches$1 = _ReactDOM$__SECRET_IN$1[5],
+      accumulateDirectDispatches$1 = _ReactDOM$__SECRET_IN$1[6],
+      enqueueStateRestore$1 = _ReactDOM$__SECRET_IN$1[7],
+      restoreStateIfNeeded$1 = _ReactDOM$__SECRET_IN$1[8],
+      dispatchEvent$1 = _ReactDOM$__SECRET_IN$1[9],
+      runEventsInBatch$1 = _ReactDOM$__SECRET_IN$1[10],
 
-function findAllInRenderedFiberTreeInternal(fiber, test) {
-  if (!fiber) {
-    return [];
-  }
+  /* eslint-disable no-unused-vars */
+  flushPassiveEffects$1 = _ReactDOM$__SECRET_IN$1[11],
+      IsThisRendererActing$1
+  /* eslint-enable no-unused-vars */
+  = _ReactDOM$__SECRET_IN$1[12];
 
-  var currentParent = findCurrentFiberUsingSlowPath(fiber);
+  function Event(suffix) {}
 
-  if (!currentParent) {
-    return [];
+  var hasWarnedAboutDeprecatedMockComponent = false;
+  /**
+   * @class ReactTestUtils
+   */
+
+  /**
+   * Simulates a top level event being dispatched from a raw event that occurred
+   * on an `Element` node.
+   * @param {number} topLevelType A number from `TopLevelEventTypes`
+   * @param {!Element} node The dom to simulate an event occurring on.
+   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
+   */
+
+  function simulateNativeEventOnNode(topLevelType, node, fakeNativeEvent) {
+    fakeNativeEvent.target = node;
+    dispatchEvent$1(topLevelType, PLUGIN_EVENT_SYSTEM, document, fakeNativeEvent);
   }
+  /**
+   * Simulates a top level event being dispatched from a raw event that occurred
+   * on the `ReactDOMComponent` `comp`.
+   * @param {Object} topLevelType A type from `BrowserEventConstants.topLevelTypes`.
+   * @param {!ReactDOMComponent} comp
+   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
+   */
 
-  var node = currentParent;
-  var ret = [];
 
-  while (true) {
-    if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent) {
-      var publicInst = node.stateNode;
+  function simulateNativeEventOnDOMComponent(topLevelType, comp, fakeNativeEvent) {
+    simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent);
+  }
 
-      if (test(publicInst)) {
-        ret.push(publicInst);
-      }
+  function findAllInRenderedFiberTreeInternal(fiber, test) {
+    if (!fiber) {
+      return [];
     }
 
-    if (node.child) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
+    var currentParent = findCurrentFiberUsingSlowPath(fiber);
 
-    if (node === currentParent) {
-      return ret;
+    if (!currentParent) {
+      return [];
     }
 
-    while (!node.sibling) {
-      if (!node.return || node.return === currentParent) {
-        return ret;
-      }
+    var node = currentParent;
+    var ret = [];
 
-      node = node.return;
-    }
+    while (true) {
+      if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent) {
+        var publicInst = node.stateNode;
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  }
-}
+        if (test(publicInst)) {
+          ret.push(publicInst);
+        }
+      }
 
-function validateClassInstance(inst, methodName) {
-  if (!inst) {
-    // This is probably too relaxed but it's existing behavior.
-    return;
-  }
+      if (node.child) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
 
-  if (get(inst)) {
-    // This is a public instance indeed.
-    return;
-  }
+      if (node === currentParent) {
+        return ret;
+      }
 
-  var received;
-  var stringified = '' + inst;
-
-  if (Array.isArray(inst)) {
-    received = 'an array';
-  } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
-    received = 'a DOM node';
-  } else if (stringified === '[object Object]') {
-    received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
-  } else {
-    received = stringified;
-  }
+      while (!node.sibling) {
+        if (!node.return || node.return === currentParent) {
+          return ret;
+        }
 
-  (function () {
-    {
-      {
-        throw ReactError(Error(methodName + "(...): the first argument must be a React class instance. Instead received: " + received + "."));
+        node = node.return;
       }
-    }
-  })();
-}
-/**
- * Utilities for making it easy to test React components.
- *
- * See https://reactjs.org/docs/test-utils.html
- *
- * Todo: Support the entire DOM.scry query syntax. For now, these simple
- * utilities will suffice for testing purposes.
- * @lends ReactTestUtils
- */
 
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
 
-var ReactTestUtils = {
-  renderIntoDocument: function (element) {
-    var div = document.createElement('div'); // None of our tests actually require attaching the container to the
-    // DOM, and doing so creates a mess that we rely on test isolation to
-    // clean up, so we're going to stop honoring the name of this method
-    // (and probably rename it eventually) if no problems arise.
-    // document.documentElement.appendChild(div);
-
-    return ReactDOM.render(element, div);
-  },
-  isElement: function (element) {
-    return React.isValidElement(element);
-  },
-  isElementOfType: function (inst, convenienceConstructor) {
-    return React.isValidElement(inst) && inst.type === convenienceConstructor;
-  },
-  isDOMComponent: function (inst) {
-    return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
-  },
-  isDOMComponentElement: function (inst) {
-    return !!(inst && React.isValidElement(inst) && !!inst.tagName);
-  },
-  isCompositeComponent: function (inst) {
-    if (ReactTestUtils.isDOMComponent(inst)) {
-      // Accessing inst.setState warns; just return false as that'll be what
-      // this returns when we have DOM nodes as refs directly
-      return false;
+  function validateClassInstance(inst, methodName) {
+    if (!inst) {
+      // This is probably too relaxed but it's existing behavior.
+      return;
     }
 
-    return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
-  },
-  isCompositeComponentWithType: function (inst, type) {
-    if (!ReactTestUtils.isCompositeComponent(inst)) {
-      return false;
+    if (get(inst)) {
+      // This is a public instance indeed.
+      return;
     }
 
-    var internalInstance = get(inst);
-    var constructor = internalInstance.type;
-    return constructor === type;
-  },
-  findAllInRenderedTree: function (inst, test) {
-    validateClassInstance(inst, 'findAllInRenderedTree');
+    var received;
+    var stringified = '' + inst;
 
-    if (!inst) {
-      return [];
+    if (Array.isArray(inst)) {
+      received = 'an array';
+    } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
+      received = 'a DOM node';
+    } else if (stringified === '[object Object]') {
+      received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
+    } else {
+      received = stringified;
     }
 
-    var internalInstance = get(inst);
-    return findAllInRenderedFiberTreeInternal(internalInstance, test);
-  },
-
+    {
+      {
+        throw Error( methodName + "(...): the first argument must be a React class instance. Instead received: " + received + "." );
+      }
+    }
+  }
   /**
-   * Finds all instance of components in the rendered tree that are DOM
-   * components with the class name matching `className`.
-   * @return {array} an array of all the matches.
+   * Utilities for making it easy to test React components.
+   *
+   * See https://reactjs.org/docs/test-utils.html
+   *
+   * Todo: Support the entire DOM.scry query syntax. For now, these simple
+   * utilities will suffice for testing purposes.
+   * @lends ReactTestUtils
    */
-  scryRenderedDOMComponentsWithClass: function (root, classNames) {
-    validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
-    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+
+
+  var ReactTestUtils = {
+    renderIntoDocument: function (element) {
+      var div = document.createElement('div'); // None of our tests actually require attaching the container to the
+      // DOM, and doing so creates a mess that we rely on test isolation to
+      // clean up, so we're going to stop honoring the name of this method
+      // (and probably rename it eventually) if no problems arise.
+      // document.documentElement.appendChild(div);
+
+      return ReactDOM.render(element, div);
+    },
+    isElement: function (element) {
+      return React.isValidElement(element);
+    },
+    isElementOfType: function (inst, convenienceConstructor) {
+      return React.isValidElement(inst) && inst.type === convenienceConstructor;
+    },
+    isDOMComponent: function (inst) {
+      return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
+    },
+    isDOMComponentElement: function (inst) {
+      return !!(inst && React.isValidElement(inst) && !!inst.tagName);
+    },
+    isCompositeComponent: function (inst) {
       if (ReactTestUtils.isDOMComponent(inst)) {
-        var className = inst.className;
+        // Accessing inst.setState warns; just return false as that'll be what
+        // this returns when we have DOM nodes as refs directly
+        return false;
+      }
 
-        if (typeof className !== 'string') {
-          // SVG, probably.
-          className = inst.getAttribute('class') || '';
-        }
+      return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
+    },
+    isCompositeComponentWithType: function (inst, type) {
+      if (!ReactTestUtils.isCompositeComponent(inst)) {
+        return false;
+      }
+
+      var internalInstance = get(inst);
+      var constructor = internalInstance.type;
+      return constructor === type;
+    },
+    findAllInRenderedTree: function (inst, test) {
+      validateClassInstance(inst, 'findAllInRenderedTree');
+
+      if (!inst) {
+        return [];
+      }
+
+      var internalInstance = get(inst);
+      return findAllInRenderedFiberTreeInternal(internalInstance, test);
+    },
+
+    /**
+     * Finds all instance of components in the rendered tree that are DOM
+     * components with the class name matching `className`.
+     * @return {array} an array of all the matches.
+     */
+    scryRenderedDOMComponentsWithClass: function (root, classNames) {
+      validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
+      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+        if (ReactTestUtils.isDOMComponent(inst)) {
+          var className = inst.className;
+
+          if (typeof className !== 'string') {
+            // SVG, probably.
+            className = inst.getAttribute('class') || '';
+          }
 
-        var classList = className.split(/\s+/);
+          var classList = className.split(/\s+/);
 
-        if (!Array.isArray(classNames)) {
-          (function () {
+          if (!Array.isArray(classNames)) {
             if (!(classNames !== undefined)) {
               {
-                throw ReactError(Error("TestUtils.scryRenderedDOMComponentsWithClass expects a className as a second argument."));
+                throw Error( "TestUtils.scryRenderedDOMComponentsWithClass expects a className as a second argument." );
               }
             }
-          })();
 
-          classNames = classNames.split(/\s+/);
+            classNames = classNames.split(/\s+/);
+          }
+
+          return classNames.every(function (name) {
+            return classList.indexOf(name) !== -1;
+          });
         }
 
-        return classNames.every(function (name) {
-          return classList.indexOf(name) !== -1;
-        });
-      }
+        return false;
+      });
+    },
 
-      return false;
-    });
-  },
+    /**
+     * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
+     * and returns that one result, or throws exception if there is any other
+     * number of matches besides one.
+     * @return {!ReactDOMComponent} The one match.
+     */
+    findRenderedDOMComponentWithClass: function (root, className) {
+      validateClassInstance(root, 'findRenderedDOMComponentWithClass');
+      var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
 
-  /**
-   * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactDOMComponent} The one match.
-   */
-  findRenderedDOMComponentWithClass: function (root, className) {
-    validateClassInstance(root, 'findRenderedDOMComponentWithClass');
-    var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
+      if (all.length !== 1) {
+        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
+      }
 
-    if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
-    }
+      return all[0];
+    },
 
-    return all[0];
-  },
+    /**
+     * Finds all instance of components in the rendered tree that are DOM
+     * components with the tag name matching `tagName`.
+     * @return {array} an array of all the matches.
+     */
+    scryRenderedDOMComponentsWithTag: function (root, tagName) {
+      validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
+      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+        return ReactTestUtils.isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
+      });
+    },
 
-  /**
-   * Finds all instance of components in the rendered tree that are DOM
-   * components with the tag name matching `tagName`.
-   * @return {array} an array of all the matches.
-   */
-  scryRenderedDOMComponentsWithTag: function (root, tagName) {
-    validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
-    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
-      return ReactTestUtils.isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
-    });
-  },
+    /**
+     * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
+     * and returns that one result, or throws exception if there is any other
+     * number of matches besides one.
+     * @return {!ReactDOMComponent} The one match.
+     */
+    findRenderedDOMComponentWithTag: function (root, tagName) {
+      validateClassInstance(root, 'findRenderedDOMComponentWithTag');
+      var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
 
-  /**
-   * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactDOMComponent} The one match.
-   */
-  findRenderedDOMComponentWithTag: function (root, tagName) {
-    validateClassInstance(root, 'findRenderedDOMComponentWithTag');
-    var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
+      if (all.length !== 1) {
+        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
+      }
 
-    if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
-    }
+      return all[0];
+    },
 
-    return all[0];
-  },
+    /**
+     * Finds all instances of components with type equal to `componentType`.
+     * @return {array} an array of all the matches.
+     */
+    scryRenderedComponentsWithType: function (root, componentType) {
+      validateClassInstance(root, 'scryRenderedComponentsWithType');
+      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+        return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
+      });
+    },
 
-  /**
-   * Finds all instances of components with type equal to `componentType`.
-   * @return {array} an array of all the matches.
-   */
-  scryRenderedComponentsWithType: function (root, componentType) {
-    validateClassInstance(root, 'scryRenderedComponentsWithType');
-    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
-      return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
-    });
-  },
+    /**
+     * Same as `scryRenderedComponentsWithType` but expects there to be one result
+     * and returns that one result, or throws exception if there is any other
+     * number of matches besides one.
+     * @return {!ReactComponent} The one match.
+     */
+    findRenderedComponentWithType: function (root, componentType) {
+      validateClassInstance(root, 'findRenderedComponentWithType');
+      var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
 
-  /**
-   * Same as `scryRenderedComponentsWithType` but expects there to be one result
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactComponent} The one match.
-   */
-  findRenderedComponentWithType: function (root, componentType) {
-    validateClassInstance(root, 'findRenderedComponentWithType');
-    var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
+      if (all.length !== 1) {
+        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
+      }
 
-    if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
-    }
+      return all[0];
+    },
+
+    /**
+     * Pass a mocked component module to this method to augment it with
+     * useful methods that allow it to be used as a dummy React component.
+     * Instead of rendering as usual, the component will become a simple
+     * <div> containing any provided children.
+     *
+     * @param {object} module the mock function object exported from a
+     *                        module that defines the component to be mocked
+     * @param {?string} mockTagName optional dummy root tag name to return
+     *                              from render method (overrides
+     *                              module.mockTagName if provided)
+     * @return {object} the ReactTestUtils object (for chaining)
+     */
+    mockComponent: function (module, mockTagName) {
+      {
+        if (!hasWarnedAboutDeprecatedMockComponent) {
+          hasWarnedAboutDeprecatedMockComponent = true;
 
-    return all[0];
-  },
+          warn('ReactTestUtils.mockComponent() is deprecated. ' + 'Use shallow rendering or jest.mock() instead.\n\n' + 'See https://fb.me/test-utils-mock-component for more information.');
+        }
+      }
 
+      mockTagName = mockTagName || module.mockTagName || 'div';
+      module.prototype.render.mockImplementation(function () {
+        return React.createElement(mockTagName, null, this.props.children);
+      });
+      return this;
+    },
+    nativeTouchData: function (x, y) {
+      return {
+        touches: [{
+          pageX: x,
+          pageY: y
+        }]
+      };
+    },
+    Simulate: null,
+    SimulateNative: {},
+    act: act
+  };
   /**
-   * Pass a mocked component module to this method to augment it with
-   * useful methods that allow it to be used as a dummy React component.
-   * Instead of rendering as usual, the component will become a simple
-   * <div> containing any provided children.
+   * Exports:
    *
-   * @param {object} module the mock function object exported from a
-   *                        module that defines the component to be mocked
-   * @param {?string} mockTagName optional dummy root tag name to return
-   *                              from render method (overrides
-   *                              module.mockTagName if provided)
-   * @return {object} the ReactTestUtils object (for chaining)
+   * - `ReactTestUtils.Simulate.click(Element)`
+   * - `ReactTestUtils.Simulate.mouseMove(Element)`
+   * - `ReactTestUtils.Simulate.change(Element)`
+   * - ... (All keys from event plugin `eventTypes` objects)
    */
-  mockComponent: function (module, mockTagName) {
-    if (!hasWarnedAboutDeprecatedMockComponent) {
-      hasWarnedAboutDeprecatedMockComponent = true;
-      lowPriorityWarningWithoutStack$1(false, 'ReactTestUtils.mockComponent() is deprecated. ' + 'Use shallow rendering or jest.mock() instead.\n\n' + 'See https://fb.me/test-utils-mock-component for more information.');
-    }
-
-    mockTagName = mockTagName || module.mockTagName || 'div';
-    module.prototype.render.mockImplementation(function () {
-      return React.createElement(mockTagName, null, this.props.children);
-    });
-    return this;
-  },
-  nativeTouchData: function (x, y) {
-    return {
-      touches: [{
-        pageX: x,
-        pageY: y
-      }]
-    };
-  },
-  Simulate: null,
-  SimulateNative: {},
-  act: act
-};
-/**
- * Exports:
- *
- * - `ReactTestUtils.Simulate.click(Element)`
- * - `ReactTestUtils.Simulate.mouseMove(Element)`
- * - `ReactTestUtils.Simulate.change(Element)`
- * - ... (All keys from event plugin `eventTypes` objects)
- */
 
-function makeSimulator(eventType) {
-  return function (domNode, eventData) {
-    (function () {
+  function makeSimulator(eventType) {
+    return function (domNode, eventData) {
       if (!!React.isValidElement(domNode)) {
         {
-          throw ReactError(Error("TestUtils.Simulate expected a DOM node as the first argument but received a React element. Pass the DOM node you wish to simulate the event on instead. Note that TestUtils.Simulate will not work if you are using shallow rendering."));
+          throw Error( "TestUtils.Simulate expected a DOM node as the first argument but received a React element. Pass the DOM node you wish to simulate the event on instead. Note that TestUtils.Simulate will not work if you are using shallow rendering." );
         }
       }
-    })();
 
-    (function () {
       if (!!ReactTestUtils.isCompositeComponent(domNode)) {
         {
-          throw ReactError(Error("TestUtils.Simulate expected a DOM node as the first argument but received a component instance. Pass the DOM node you wish to simulate the event on instead."));
+          throw Error( "TestUtils.Simulate expected a DOM node as the first argument but received a component instance. Pass the DOM node you wish to simulate the event on instead." );
         }
       }
-    })();
-
-    var dispatchConfig = eventNameDispatchConfigs[eventType];
-    var fakeNativeEvent = new Event();
-    fakeNativeEvent.target = domNode;
-    fakeNativeEvent.type = eventType.toLowerCase(); // We don't use SyntheticEvent.getPooled in order to not have to worry about
-    // properly destroying any properties assigned from `eventData` upon release
 
-    var targetInst = getInstanceFromNode(domNode);
-    var event = new SyntheticEvent(dispatchConfig, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
-    // sure it's marked and won't warn when setting additional properties.
+      var dispatchConfig = eventNameDispatchConfigs$1[eventType];
+      var fakeNativeEvent = new Event();
+      fakeNativeEvent.target = domNode;
+      fakeNativeEvent.type = eventType.toLowerCase(); // We don't use SyntheticEvent.getPooled in order to not have to worry about
+      // properly destroying any properties assigned from `eventData` upon release
 
-    event.persist();
+      var targetInst = getInstanceFromNode$1(domNode);
+      var event = new SyntheticEvent(dispatchConfig, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
+      // sure it's marked and won't warn when setting additional properties.
 
-    _assign(event, eventData);
-
-    if (dispatchConfig.phasedRegistrationNames) {
-      accumulateTwoPhaseDispatches(event);
-    } else {
-      accumulateDirectDispatches(event);
-    }
+      event.persist();
 
-    ReactDOM.unstable_batchedUpdates(function () {
-      // Normally extractEvent enqueues a state restore, but we'll just always
-      // do that since we're by-passing it here.
-      enqueueStateRestore(domNode);
-      runEventsInBatch(event);
-    });
-    restoreStateIfNeeded();
-  };
-}
+      _assign(event, eventData);
 
-function buildSimulators() {
-  ReactTestUtils.Simulate = {};
-  var eventType;
+      if (dispatchConfig.phasedRegistrationNames) {
+        accumulateTwoPhaseDispatches$1(event);
+      } else {
+        accumulateDirectDispatches$1(event);
+      }
 
-  for (eventType in eventNameDispatchConfigs) {
-    /**
-     * @param {!Element|ReactDOMComponent} domComponentOrNode
-     * @param {?object} eventData Fake event data to use in SyntheticEvent.
-     */
-    ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);
+      ReactDOM.unstable_batchedUpdates(function () {
+        // Normally extractEvent enqueues a state restore, but we'll just always
+        // do that since we're by-passing it here.
+        enqueueStateRestore$1(domNode);
+        runEventsInBatch$1(event);
+      });
+      restoreStateIfNeeded$1();
+    };
   }
-}
 
-buildSimulators();
-/**
- * Exports:
- *
- * - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)`
- * - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)`
- * - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)`
- * - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)`
- * - ... (All keys from `BrowserEventConstants.topLevelTypes`)
- *
- * Note: Top level event types are a subset of the entire set of handler types
- * (which include a broader set of "synthetic" events). For example, onDragDone
- * is a synthetic event. Except when testing an event plugin or React's event
- * handling code specifically, you probably want to use ReactTestUtils.Simulate
- * to dispatch synthetic events.
- */
+  function buildSimulators() {
+    ReactTestUtils.Simulate = {};
+    var eventType;
 
-function makeNativeSimulator(eventType, topLevelType) {
-  return function (domComponentOrNode, nativeEventData) {
-    var fakeNativeEvent = new Event(eventType);
-
-    _assign(fakeNativeEvent, nativeEventData);
-
-    if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
-      simulateNativeEventOnDOMComponent(topLevelType, domComponentOrNode, fakeNativeEvent);
-    } else if (domComponentOrNode.tagName) {
-      // Will allow on actual dom nodes.
-      simulateNativeEventOnNode(topLevelType, domComponentOrNode, fakeNativeEvent);
+    for (eventType in eventNameDispatchConfigs$1) {
+      /**
+       * @param {!Element|ReactDOMComponent} domComponentOrNode
+       * @param {?object} eventData Fake event data to use in SyntheticEvent.
+       */
+      ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);
     }
-  };
-}
-
-[[TOP_ABORT, 'abort'], [TOP_ANIMATION_END, 'animationEnd'], [TOP_ANIMATION_ITERATION, 'animationIteration'], [TOP_ANIMATION_START, 'animationStart'], [TOP_BLUR, 'blur'], [TOP_CAN_PLAY_THROUGH, 'canPlayThrough'], [TOP_CAN_PLAY, 'canPlay'], [TOP_CANCEL, 'cancel'], [TOP_CHANGE, 'change'], [TOP_CLICK, 'click'], [TOP_CLOSE, 'close'], [TOP_COMPOSITION_END, 'compositionEnd'], [TOP_COMPOSITION_START, 'compositionStart'], [TOP_COMPOSITION_UPDATE, 'compositionUpdate'], [TOP_CONTEXT_MENU, 'contextMenu'], [TOP_COPY, 'copy'], [TOP_CUT, 'cut'], [TOP_DOUBLE_CLICK, 'doubleClick'], [TOP_DRAG_END, 'dragEnd'], [TOP_DRAG_ENTER, 'dragEnter'], [TOP_DRAG_EXIT, 'dragExit'], [TOP_DRAG_LEAVE, 'dragLeave'], [TOP_DRAG_OVER, 'dragOver'], [TOP_DRAG_START, 'dragStart'], [TOP_DRAG, 'drag'], [TOP_DROP, 'drop'], [TOP_DURATION_CHANGE, 'durationChange'], [TOP_EMPTIED, 'emptied'], [TOP_ENCRYPTED, 'encrypted'], [TOP_ENDED, 'ended'], [TOP_ERROR, 'error'], [TOP_FOCUS, 'focus'], [TOP_INPUT, 'input'], [TOP_KEY_DOWN, 'keyDown'], [TOP_KEY_PRESS, 'keyPress'], [TOP_KEY_UP, 'keyUp'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD, 'load'], [TOP_LOADED_DATA, 'loadedData'], [TOP_LOADED_METADATA, 'loadedMetadata'], [TOP_MOUSE_DOWN, 'mouseDown'], [TOP_MOUSE_MOVE, 'mouseMove'], [TOP_MOUSE_OUT, 'mouseOut'], [TOP_MOUSE_OVER, 'mouseOver'], [TOP_MOUSE_UP, 'mouseUp'], [TOP_PASTE, 'paste'], [TOP_PAUSE, 'pause'], [TOP_PLAY, 'play'], [TOP_PLAYING, 'playing'], [TOP_PROGRESS, 'progress'], [TOP_RATE_CHANGE, 'rateChange'], [TOP_SCROLL, 'scroll'], [TOP_SEEKED, 'seeked'], [TOP_SEEKING, 'seeking'], [TOP_SELECTION_CHANGE, 'selectionChange'], [TOP_STALLED, 'stalled'], [TOP_SUSPEND, 'suspend'], [TOP_TEXT_INPUT, 'textInput'], [TOP_TIME_UPDATE, 'timeUpdate'], [TOP_TOGGLE, 'toggle'], [TOP_TOUCH_CANCEL, 'touchCancel'], [TOP_TOUCH_END, 'touchEnd'], [TOP_TOUCH_MOVE, 'touchMove'], [TOP_TOUCH_START, 'touchStart'], [TOP_TRANSITION_END, 'transitionEnd'], [TOP_VOLUME_CHANGE, 'volumeChange'], [TOP_WAITING, 'waiting'], [TOP_WHEEL, 'wheel']].forEach(function (_ref) {
-  var topLevelType = _ref[0],
-      eventType = _ref[1];
+  }
 
+  buildSimulators();
   /**
-   * @param {!Element|ReactDOMComponent} domComponentOrNode
-   * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
+   * Exports:
+   *
+   * - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)`
+   * - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)`
+   * - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)`
+   * - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)`
+   * - ... (All keys from `BrowserEventConstants.topLevelTypes`)
+   *
+   * Note: Top level event types are a subset of the entire set of handler types
+   * (which include a broader set of "synthetic" events). For example, onDragDone
+   * is a synthetic event. Except when testing an event plugin or React's event
+   * handling code specifically, you probably want to use ReactTestUtils.Simulate
+   * to dispatch synthetic events.
    */
-  ReactTestUtils.SimulateNative[eventType] = makeNativeSimulator(eventType, topLevelType);
-});
 
+  function makeNativeSimulator(eventType, topLevelType) {
+    return function (domComponentOrNode, nativeEventData) {
+      var fakeNativeEvent = new Event(eventType);
 
-var ReactTestUtils$2 = Object.freeze({
-	default: ReactTestUtils
-});
+      _assign(fakeNativeEvent, nativeEventData);
 
-var ReactTestUtils$3 = ( ReactTestUtils$2 && ReactTestUtils ) || ReactTestUtils$2;
+      if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
+        simulateNativeEventOnDOMComponent(topLevelType, domComponentOrNode, fakeNativeEvent);
+      } else if (domComponentOrNode.tagName) {
+        // Will allow on actual dom nodes.
+        simulateNativeEventOnNode(topLevelType, domComponentOrNode, fakeNativeEvent);
+      }
+    };
+  }
+
+  [[TOP_ABORT, 'abort'], [TOP_ANIMATION_END, 'animationEnd'], [TOP_ANIMATION_ITERATION, 'animationIteration'], [TOP_ANIMATION_START, 'animationStart'], [TOP_BLUR, 'blur'], [TOP_CAN_PLAY_THROUGH, 'canPlayThrough'], [TOP_CAN_PLAY, 'canPlay'], [TOP_CANCEL, 'cancel'], [TOP_CHANGE, 'change'], [TOP_CLICK, 'click'], [TOP_CLOSE, 'close'], [TOP_COMPOSITION_END, 'compositionEnd'], [TOP_COMPOSITION_START, 'compositionStart'], [TOP_COMPOSITION_UPDATE, 'compositionUpdate'], [TOP_CONTEXT_MENU, 'contextMenu'], [TOP_COPY, 'copy'], [TOP_CUT, 'cut'], [TOP_DOUBLE_CLICK, 'doubleClick'], [TOP_DRAG_END, 'dragEnd'], [TOP_DRAG_ENTER, 'dragEnter'], [TOP_DRAG_EXIT, 'dragExit'], [TOP_DRAG_LEAVE, 'dragLeave'], [TOP_DRAG_OVER, 'dragOver'], [TOP_DRAG_START, 'dragStart'], [TOP_DRAG, 'drag'], [TOP_DROP, 'drop'], [TOP_DURATION_CHANGE, 'durationChange'], [TOP_EMPTIED, 'emptied'], [TOP_ENCRYPTED, 'encrypted'], [TOP_ENDED, 'ended'], [TOP_ERROR, 'error'], [TOP_FOCUS, 'focus'], [TOP_INPUT, 'input'], [TOP_KEY_DOWN, 'keyDown'], [TOP_KEY_PRESS, 'keyPress'], [TOP_KEY_UP, 'keyUp'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD, 'load'], [TOP_LOADED_DATA, 'loadedData'], [TOP_LOADED_METADATA, 'loadedMetadata'], [TOP_MOUSE_DOWN, 'mouseDown'], [TOP_MOUSE_MOVE, 'mouseMove'], [TOP_MOUSE_OUT, 'mouseOut'], [TOP_MOUSE_OVER, 'mouseOver'], [TOP_MOUSE_UP, 'mouseUp'], [TOP_PASTE, 'paste'], [TOP_PAUSE, 'pause'], [TOP_PLAY, 'play'], [TOP_PLAYING, 'playing'], [TOP_PROGRESS, 'progress'], [TOP_RATE_CHANGE, 'rateChange'], [TOP_SCROLL, 'scroll'], [TOP_SEEKED, 'seeked'], [TOP_SEEKING, 'seeking'], [TOP_SELECTION_CHANGE, 'selectionChange'], [TOP_STALLED, 'stalled'], [TOP_SUSPEND, 'suspend'], [TOP_TEXT_INPUT, 'textInput'], [TOP_TIME_UPDATE, 'timeUpdate'], [TOP_TOGGLE, 'toggle'], [TOP_TOUCH_CANCEL, 'touchCancel'], [TOP_TOUCH_END, 'touchEnd'], [TOP_TOUCH_MOVE, 'touchMove'], [TOP_TOUCH_START, 'touchStart'], [TOP_TRANSITION_END, 'transitionEnd'], [TOP_VOLUME_CHANGE, 'volumeChange'], [TOP_WAITING, 'waiting'], [TOP_WHEEL, 'wheel']].forEach(function (_ref) {
+    var topLevelType = _ref[0],
+        eventType = _ref[1];
+
+    /**
+     * @param {!Element|ReactDOMComponent} domComponentOrNode
+     * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
+     */
+    ReactTestUtils.SimulateNative[eventType] = makeNativeSimulator(eventType, topLevelType);
+  });
 
-// TODO: decide on the top-level export form.
-// This is hacky but makes it work with both Rollup and Jest.
+  // TODO: decide on the top-level export form.
+  // This is hacky but makes it work with both Rollup and Jest.
 
 
-var testUtils = ReactTestUtils$3.default || ReactTestUtils$3;
+  var testUtils = ReactTestUtils.default || ReactTestUtils;
 
-return testUtils;
+  return testUtils;
 
 })));