one 1.2.46 → 1.2.48

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

@@ -7,13 +7,17 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom'], factory) :
-  (global = global || self, factory(global.ReactTestUtils = {}, global.React, global.ReactDOM));
-}(this, (function (exports, React, ReactDOM) { 'use strict';
-
-  var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+;(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports, require('react'), require('react-dom'))
+    : typeof define === 'function' && define.amd
+      ? define(['exports', 'react', 'react-dom'], factory)
+      : ((global = global || self),
+        factory((global.ReactTestUtils = {}), global.React, global.ReactDOM))
+})(this, function (exports, React, ReactDOM) {
+  'use strict'
+
+  var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
 
   // by calls to these methods by a Babel plugin.
   //
@@ -23,22 +27,34 @@
   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];
+        for (
+          var _len = arguments.length,
+            args = new Array(_len > 1 ? _len - 1 : 0),
+            _key = 1;
+          _key < _len;
+          _key++
+        ) {
+          args[_key - 1] = arguments[_key]
         }
 
-        printWarning('warn', format, args);
+        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];
+        for (
+          var _len2 = arguments.length,
+            args = new Array(_len2 > 1 ? _len2 - 1 : 0),
+            _key2 = 1;
+          _key2 < _len2;
+          _key2++
+        ) {
+          args[_key2 - 1] = arguments[_key2]
         }
 
-        printWarning('error', format, args);
+        printWarning('error', format, args)
       }
     }
   }
@@ -47,24 +63,23 @@
     // When changing this logic, you might want to also
     // update consoleWithStackDev.www.js as well.
     {
-      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-      var stack = ReactDebugCurrentFrame.getStackAddendum();
+      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame
+      var stack = ReactDebugCurrentFrame.getStackAddendum()
 
       if (stack !== '') {
-        format += '%s';
-        args = args.concat([stack]);
+        format += '%s'
+        args = args.concat([stack])
       } // eslint-disable-next-line react-internal/safe-string-coercion
 
-
       var argsWithFormat = args.map(function (item) {
-        return String(item);
-      }); // Careful: RN currently depends on this prefix
+        return String(item)
+      }) // Careful: RN currently depends on this prefix
 
-      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+      argsWithFormat.unshift('Warning: ' + format) // We intentionally don't use spread (or .apply) directly because it
       // breaks IE9: https://github.com/facebook/react/issues/13610
       // eslint-disable-next-line react-internal/no-production-logging
 
-      Function.prototype.apply.call(console[level], console, argsWithFormat);
+      Function.prototype.apply.call(console[level], console, argsWithFormat)
     }
   }
 
@@ -78,149 +93,144 @@
    * If this becomes an actual Map, that will break.
    */
   function get(key) {
-    return key._reactInternals;
+    return key._reactInternals
   }
 
-  var FunctionComponent = 0;
-  var ClassComponent = 1;
+  var FunctionComponent = 0
+  var ClassComponent = 1
 
-  var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+  var HostRoot = 3 // Root of a host tree. Could be nested inside another node.
 
-  var HostComponent = 5;
-  var HostText = 6;
+  var HostComponent = 5
+  var HostText = 6
 
   // Don't change these two values. They're used by React Dev Tools.
   var NoFlags =
-  /*                      */
-  0;
+    /*                      */
+    0
 
   var Placement =
-  /*                    */
-  2;
+    /*                    */
+    2
   var Hydrating =
-  /*                    */
-  4096;
+    /*                    */
+    4096
 
-  var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+  var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner
   function getNearestMountedFiber(fiber) {
-    var node = fiber;
-    var nearestMounted = 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;
+      var nextNode = node
 
       do {
-        node = nextNode;
+        node = nextNode
 
         if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
           // 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;
+          nearestMounted = node.return
         }
 
-        nextNode = node.return;
-      } while (nextNode);
+        nextNode = node.return
+      } while (nextNode)
     } else {
       while (node.return) {
-        node = node.return;
+        node = node.return
       }
     }
 
     if (node.tag === HostRoot) {
       // TODO: Check if this was a nested HostRoot when used with
       // renderContainerIntoSubtree.
-      return nearestMounted;
+      return nearestMounted
     } // If we didn't hit the root, that means that we're in an disconnected tree
     // that has been unmounted.
 
-
-    return null;
+    return null
   }
 
   function assertIsMounted(fiber) {
     if (getNearestMountedFiber(fiber) !== fiber) {
-      throw new Error('Unable to find node on an unmounted component.');
+      throw new Error('Unable to find node on an unmounted component.')
     }
   }
 
   function findCurrentFiberUsingSlowPath(fiber) {
-    var alternate = fiber.alternate;
+    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);
+      var nearestMounted = getNearestMountedFiber(fiber)
 
       if (nearestMounted === null) {
-        throw new Error('Unable to find node on an unmounted component.');
+        throw new Error('Unable to find node on an unmounted component.')
       }
 
       if (nearestMounted !== fiber) {
-        return null;
+        return null
       }
 
-      return fiber;
+      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;
+      var parentA = a.return
 
       if (parentA === null) {
         // We're at the root.
-        break;
+        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;
+        var nextParent = parentA.return
 
         if (nextParent !== null) {
-          a = b = nextParent;
-          continue;
+          a = b = nextParent
+          continue
         } // If there's no parent, we're at the root.
 
-
-        break;
+        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;
+        var child = parentA.child
 
         while (child) {
           if (child === a) {
             // We've determined that A is the current branch.
-            assertIsMounted(parentA);
-            return fiber;
+            assertIsMounted(parentA)
+            return fiber
           }
 
           if (child === b) {
             // We've determined that B is the current branch.
-            assertIsMounted(parentA);
-            return alternate;
+            assertIsMounted(parentA)
+            return alternate
           }
 
-          child = child.sibling;
+          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.
 
-
-        throw new Error('Unable to find node on an unmounted component.');
+        throw new Error('Unable to find node on an unmounted component.')
       }
 
       if (a.return !== b.return) {
@@ -228,84 +238,88 @@
         // 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;
+        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;
+        var didFindChild = false
+        var _child = parentA.child
 
         while (_child) {
           if (_child === a) {
-            didFindChild = true;
-            a = parentA;
-            b = parentB;
-            break;
+            didFindChild = true
+            a = parentA
+            b = parentB
+            break
           }
 
           if (_child === b) {
-            didFindChild = true;
-            b = parentA;
-            a = parentB;
-            break;
+            didFindChild = true
+            b = parentA
+            a = parentB
+            break
           }
 
-          _child = _child.sibling;
+          _child = _child.sibling
         }
 
         if (!didFindChild) {
           // Search parent B's child set
-          _child = parentB.child;
+          _child = parentB.child
 
           while (_child) {
             if (_child === a) {
-              didFindChild = true;
-              a = parentB;
-              b = parentA;
-              break;
+              didFindChild = true
+              a = parentB
+              b = parentA
+              break
             }
 
             if (_child === b) {
-              didFindChild = true;
-              b = parentB;
-              a = parentA;
-              break;
+              didFindChild = true
+              b = parentB
+              a = parentA
+              break
             }
 
-            _child = _child.sibling;
+            _child = _child.sibling
           }
 
           if (!didFindChild) {
-            throw new 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 new Error(
+              'Child was not found in either parent set. This indicates a bug ' +
+                'in React related to the return pointer. Please file an issue.'
+            )
           }
         }
       }
 
       if (a.alternate !== b) {
-        throw new Error("Return fibers should always be each others' alternates. " + 'This error is likely caused by a bug in React. Please file an issue.');
+        throw new 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 (a.tag !== HostRoot) {
-      throw new Error('Unable to find node on an unmounted component.');
+      throw new 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;
+      return fiber
     } // Otherwise B has to be current branch.
 
-
-    return alternate;
+    return alternate
   }
 
-  var assign = Object.assign;
+  var assign = Object.assign
 
   /**
    * `charCode` represents the actual "character code" and is safe to use with
@@ -318,45 +332,42 @@
    * @return {number} Normalized `charCode` property.
    */
   function getEventCharCode(nativeEvent) {
-    var charCode;
-    var keyCode = nativeEvent.keyCode;
+    var charCode
+    var keyCode = nativeEvent.keyCode
 
     if ('charCode' in nativeEvent) {
-      charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+      charCode = nativeEvent.charCode // FF does not set `charCode` for the Enter-key, check against `keyCode`.
 
       if (charCode === 0 && keyCode === 13) {
-        charCode = 13;
+        charCode = 13
       }
     } else {
       // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-      charCode = keyCode;
+      charCode = keyCode
     } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
     // report Enter as charCode 10 when ctrl is pressed.
 
-
     if (charCode === 10) {
-      charCode = 13;
+      charCode = 13
     } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
     // Must not discard the (non-)printable Enter-key.
 
-
     if (charCode >= 32 || charCode === 13) {
-      return charCode;
+      return charCode
     }
 
-    return 0;
+    return 0
   }
 
   function functionThatReturnsTrue() {
-    return true;
+    return true
   }
 
   function functionThatReturnsFalse() {
-    return false;
+    return false
   } // This is intentionally a factory so that we have different returned constructors.
   // If we had a single constructor, it would be megamorphic and engines would deopt.
 
-
   function createSyntheticEvent(Interface) {
     /**
      * Synthetic events are dispatched by event plugins, typically in response to a
@@ -371,76 +382,85 @@
      * normalizing browser quirks. Subclasses do not necessarily have to implement a
      * DOM interface; custom application-specific events can also subclass this.
      */
-    function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
-      this._reactName = reactName;
-      this._targetInst = targetInst;
-      this.type = reactEventType;
-      this.nativeEvent = nativeEvent;
-      this.target = nativeEventTarget;
-      this.currentTarget = null;
+    function SyntheticBaseEvent(
+      reactName,
+      reactEventType,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    ) {
+      this._reactName = reactName
+      this._targetInst = targetInst
+      this.type = reactEventType
+      this.nativeEvent = nativeEvent
+      this.target = nativeEventTarget
+      this.currentTarget = null
 
       for (var _propName in Interface) {
         if (!Interface.hasOwnProperty(_propName)) {
-          continue;
+          continue
         }
 
-        var normalize = Interface[_propName];
+        var normalize = Interface[_propName]
 
         if (normalize) {
-          this[_propName] = normalize(nativeEvent);
+          this[_propName] = normalize(nativeEvent)
         } else {
-          this[_propName] = nativeEvent[_propName];
+          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;
+        this.isDefaultPrevented = functionThatReturnsTrue
       } else {
-        this.isDefaultPrevented = functionThatReturnsFalse;
+        this.isDefaultPrevented = functionThatReturnsFalse
       }
 
-      this.isPropagationStopped = functionThatReturnsFalse;
-      return this;
+      this.isPropagationStopped = functionThatReturnsFalse
+      return this
     }
 
     assign(SyntheticBaseEvent.prototype, {
       preventDefault: function () {
-        this.defaultPrevented = true;
-        var event = this.nativeEvent;
+        this.defaultPrevented = true
+        var event = this.nativeEvent
 
         if (!event) {
-          return;
+          return
         }
 
         if (event.preventDefault) {
-          event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
+          event.preventDefault() // $FlowFixMe - flow is not aware of `unknown` in IE
         } else if (typeof event.returnValue !== 'unknown') {
-          event.returnValue = false;
+          event.returnValue = false
         }
 
-        this.isDefaultPrevented = functionThatReturnsTrue;
+        this.isDefaultPrevented = functionThatReturnsTrue
       },
       stopPropagation: function () {
-        var event = this.nativeEvent;
+        var event = this.nativeEvent
 
         if (!event) {
-          return;
+          return
         }
 
         if (event.stopPropagation) {
-          event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
+          event.stopPropagation() // $FlowFixMe - flow is not aware of `unknown` in IE
         } 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;
+          event.cancelBubble = true
         }
 
-        this.isPropagationStopped = functionThatReturnsTrue;
+        this.isPropagationStopped = functionThatReturnsTrue
       },
 
       /**
@@ -448,7 +468,8 @@
        * 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 () {// Modern event system doesn't use pooling.
+      persist: function () {
+        // Modern event system doesn't use pooling.
       },
 
       /**
@@ -456,49 +477,48 @@
        *
        * @return {boolean} True if this should not be released, false otherwise.
        */
-      isPersistent: functionThatReturnsTrue
-    });
-    return SyntheticBaseEvent;
+      isPersistent: functionThatReturnsTrue,
+    })
+    return SyntheticBaseEvent
   }
   /**
    * @interface Event
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
    */
 
-
   var EventInterface = {
     eventPhase: 0,
     bubbles: 0,
     cancelable: 0,
     timeStamp: function (event) {
-      return event.timeStamp || Date.now();
+      return event.timeStamp || Date.now()
     },
     defaultPrevented: 0,
-    isTrusted: 0
-  };
-  var SyntheticEvent = createSyntheticEvent(EventInterface);
+    isTrusted: 0,
+  }
+  var SyntheticEvent = createSyntheticEvent(EventInterface)
 
   var UIEventInterface = assign({}, EventInterface, {
     view: 0,
-    detail: 0
-  });
+    detail: 0,
+  })
 
-  var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
-  var lastMovementX;
-  var lastMovementY;
-  var lastMouseEvent;
+  var SyntheticUIEvent = createSyntheticEvent(UIEventInterface)
+  var lastMovementX
+  var lastMovementY
+  var lastMouseEvent
 
   function updateMouseMovementPolyfillState(event) {
     if (event !== lastMouseEvent) {
       if (lastMouseEvent && event.type === 'mousemove') {
-        lastMovementX = event.screenX - lastMouseEvent.screenX;
-        lastMovementY = event.screenY - lastMouseEvent.screenY;
+        lastMovementX = event.screenX - lastMouseEvent.screenX
+        lastMovementY = event.screenY - lastMouseEvent.screenY
       } else {
-        lastMovementX = 0;
-        lastMovementY = 0;
+        lastMovementX = 0
+        lastMovementY = 0
       }
 
-      lastMouseEvent = event;
+      lastMouseEvent = event
     }
   }
   /**
@@ -506,7 +526,6 @@
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
    */
 
-
   var MouseEventInterface = assign({}, UIEventInterface, {
     screenX: 0,
     screenY: 0,
@@ -522,50 +541,52 @@
     button: 0,
     buttons: 0,
     relatedTarget: function (event) {
-      if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;
-      return event.relatedTarget;
+      if (event.relatedTarget === undefined)
+        return event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+      return event.relatedTarget
     },
     movementX: function (event) {
       if ('movementX' in event) {
-        return event.movementX;
+        return event.movementX
       }
 
-      updateMouseMovementPolyfillState(event);
-      return lastMovementX;
+      updateMouseMovementPolyfillState(event)
+      return lastMovementX
     },
     movementY: function (event) {
       if ('movementY' in event) {
-        return event.movementY;
+        return event.movementY
       } // Don't need to call updateMouseMovementPolyfillState() here
       // because it's guaranteed to have already run when movementX
       // was copied.
 
+      return lastMovementY
+    },
+  })
 
-      return lastMovementY;
-    }
-  });
-
-  var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+  var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface)
   /**
    * @interface DragEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
    */
 
   var DragEventInterface = assign({}, MouseEventInterface, {
-    dataTransfer: 0
-  });
+    dataTransfer: 0,
+  })
 
-  var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+  var SyntheticDragEvent = createSyntheticEvent(DragEventInterface)
   /**
    * @interface FocusEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
    */
 
   var FocusEventInterface = assign({}, UIEventInterface, {
-    relatedTarget: 0
-  });
+    relatedTarget: 0,
+  })
 
-  var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+  var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface)
   /**
    * @interface Event
    * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
@@ -575,10 +596,10 @@
   var AnimationEventInterface = assign({}, EventInterface, {
     animationName: 0,
     elapsedTime: 0,
-    pseudoElement: 0
-  });
+    pseudoElement: 0,
+  })
 
-  var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+  var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface)
   /**
    * @interface Event
    * @see http://www.w3.org/TR/clipboard-apis/
@@ -586,21 +607,21 @@
 
   var ClipboardEventInterface = assign({}, EventInterface, {
     clipboardData: function (event) {
-      return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
-    }
-  });
+      return 'clipboardData' in event ? event.clipboardData : window.clipboardData
+    },
+  })
 
-  var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+  var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface)
   /**
    * @interface Event
    * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
    */
 
   var CompositionEventInterface = assign({}, EventInterface, {
-    data: 0
-  });
+    data: 0,
+  })
 
-  var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+  var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface)
   /**
    * Normalization of deprecated HTML5 `key` values
    * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
@@ -618,8 +639,8 @@
     Menu: 'ContextMenu',
     Apps: 'ContextMenu',
     Scroll: 'ScrollLock',
-    MozPrintableKey: 'Unidentified'
-  };
+    MozPrintableKey: 'Unidentified',
+  }
   /**
    * Translation from legacy `keyCode` to HTML5 `key`
    * Only special keys supported, all others depend on keyboard layout or browser
@@ -627,43 +648,43 @@
    */
 
   var translateToKey = {
-    '8': 'Backspace',
-    '9': 'Tab',
-    '12': 'Clear',
-    '13': 'Enter',
-    '16': 'Shift',
-    '17': 'Control',
-    '18': 'Alt',
-    '19': 'Pause',
-    '20': 'CapsLock',
-    '27': 'Escape',
-    '32': ' ',
-    '33': 'PageUp',
-    '34': 'PageDown',
-    '35': 'End',
-    '36': 'Home',
-    '37': 'ArrowLeft',
-    '38': 'ArrowUp',
-    '39': 'ArrowRight',
-    '40': 'ArrowDown',
-    '45': 'Insert',
-    '46': 'Delete',
-    '112': 'F1',
-    '113': 'F2',
-    '114': 'F3',
-    '115': 'F4',
-    '116': 'F5',
-    '117': 'F6',
-    '118': 'F7',
-    '119': 'F8',
-    '120': 'F9',
-    '121': 'F10',
-    '122': 'F11',
-    '123': 'F12',
-    '144': 'NumLock',
-    '145': 'ScrollLock',
-    '224': 'Meta'
-  };
+    8: 'Backspace',
+    9: 'Tab',
+    12: 'Clear',
+    13: 'Enter',
+    16: 'Shift',
+    17: 'Control',
+    18: 'Alt',
+    19: 'Pause',
+    20: 'CapsLock',
+    27: 'Escape',
+    32: ' ',
+    33: 'PageUp',
+    34: 'PageDown',
+    35: 'End',
+    36: 'Home',
+    37: 'ArrowLeft',
+    38: 'ArrowUp',
+    39: 'ArrowRight',
+    40: 'ArrowDown',
+    45: 'Insert',
+    46: 'Delete',
+    112: 'F1',
+    113: 'F2',
+    114: 'F3',
+    115: 'F4',
+    116: 'F5',
+    117: 'F6',
+    118: 'F7',
+    119: 'F8',
+    120: 'F9',
+    121: 'F10',
+    122: 'F11',
+    123: 'F12',
+    144: 'NumLock',
+    145: 'ScrollLock',
+    224: 'Meta',
+  }
   /**
    * @param {object} nativeEvent Native browser event.
    * @return {string} Normalized `key` property.
@@ -675,65 +696,62 @@
       // implementations of a working draft specification.
       // FireFox implements `key` but returns `MozPrintableKey` for all
       // printable characters (normalized to `Unidentified`), ignore it.
-      var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+      var key = normalizeKey[nativeEvent.key] || nativeEvent.key
 
       if (key !== 'Unidentified') {
-        return key;
+        return key
       }
     } // Browser does not implement `key`, polyfill as much of it as we can.
 
-
     if (nativeEvent.type === 'keypress') {
-      var charCode = getEventCharCode(nativeEvent); // The enter-key is technically both printable and non-printable and can
+      var charCode = getEventCharCode(nativeEvent) // The enter-key is technically both printable and non-printable and can
       // thus be captured by `keypress`, no other non-printable key should.
 
-      return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+      return charCode === 13 ? 'Enter' : String.fromCharCode(charCode)
     }
 
     if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
       // While user keyboard layout determines the actual meaning of each
       // `keyCode` value, almost all function keys have a universal value.
-      return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+      return translateToKey[nativeEvent.keyCode] || 'Unidentified'
     }
 
-    return '';
+    return ''
   }
   /**
    * Translation from modifier key to the associated property in the event.
    * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
    */
 
-
   var modifierKeyToProp = {
     Alt: 'altKey',
     Control: 'ctrlKey',
     Meta: 'metaKey',
-    Shift: 'shiftKey'
-  }; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+    Shift: 'shiftKey',
+  } // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
   // getModifierState. If getModifierState is not supported, we map it to a set of
   // modifier keys exposed by the event. In this case, Lock-keys are not supported.
 
   function modifierStateGetter(keyArg) {
-    var syntheticEvent = this;
-    var nativeEvent = syntheticEvent.nativeEvent;
+    var syntheticEvent = this
+    var nativeEvent = syntheticEvent.nativeEvent
 
     if (nativeEvent.getModifierState) {
-      return nativeEvent.getModifierState(keyArg);
+      return nativeEvent.getModifierState(keyArg)
     }
 
-    var keyProp = modifierKeyToProp[keyArg];
-    return keyProp ? !!nativeEvent[keyProp] : false;
+    var keyProp = modifierKeyToProp[keyArg]
+    return keyProp ? !!nativeEvent[keyProp] : false
   }
 
   function getEventModifierState(nativeEvent) {
-    return modifierStateGetter;
+    return modifierStateGetter
   }
   /**
    * @interface KeyboardEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
    */
 
-
   var KeyboardEventInterface = assign({}, UIEventInterface, {
     key: getEventKey,
     code: 0,
@@ -752,10 +770,10 @@
       // KeyPress is deprecated, but its replacement is not yet final and not
       // implemented in any major browser. Only KeyPress has charCode.
       if (event.type === 'keypress') {
-        return getEventCharCode(event);
+        return getEventCharCode(event)
       }
 
-      return 0;
+      return 0
     },
     keyCode: function (event) {
       // `keyCode` is the result of a KeyDown/Up event and represents the value of
@@ -765,27 +783,27 @@
       // provides a surprisingly accurate mapping for US and European users.
       // Due to this, it is left to the user to implement at this time.
       if (event.type === 'keydown' || event.type === 'keyup') {
-        return event.keyCode;
+        return event.keyCode
       }
 
-      return 0;
+      return 0
     },
     which: function (event) {
       // `which` is an alias for either `keyCode` or `charCode` depending on the
       // type of the event.
       if (event.type === 'keypress') {
-        return getEventCharCode(event);
+        return getEventCharCode(event)
       }
 
       if (event.type === 'keydown' || event.type === 'keyup') {
-        return event.keyCode;
+        return event.keyCode
       }
 
-      return 0;
-    }
-  });
+      return 0
+    },
+  })
 
-  var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+  var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface)
   /**
    * @interface PointerEvent
    * @see http://www.w3.org/TR/pointerevents/
@@ -801,10 +819,10 @@
     tiltY: 0,
     twist: 0,
     pointerType: 0,
-    isPrimary: 0
-  });
+    isPrimary: 0,
+  })
 
-  var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+  var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface)
   /**
    * @interface TouchEvent
    * @see http://www.w3.org/TR/touch-events/
@@ -818,10 +836,10 @@
     metaKey: 0,
     ctrlKey: 0,
     shiftKey: 0,
-    getModifierState: getEventModifierState
-  });
+    getModifierState: getEventModifierState,
+  })
 
-  var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+  var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface)
   /**
    * @interface Event
    * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
@@ -831,10 +849,10 @@
   var TransitionEventInterface = assign({}, EventInterface, {
     propertyName: 0,
     elapsedTime: 0,
-    pseudoElement: 0
-  });
+    pseudoElement: 0,
+  })
 
-  var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+  var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface)
   /**
    * @interface WheelEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -842,40 +860,47 @@
 
   var WheelEventInterface = assign({}, MouseEventInterface, {
     deltaX: function (event) {
-      return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
-      'wheelDeltaX' in event ? -event.wheelDeltaX : 0;
+      return 'deltaX' in event
+        ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+        : 'wheelDeltaX' in event
+          ? -event.wheelDeltaX
+          : 0
     },
     deltaY: function (event) {
-      return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
-      'wheelDeltaY' in event ? -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
-      'wheelDelta' in event ? -event.wheelDelta : 0;
+      return 'deltaY' in event
+        ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+        : 'wheelDeltaY' in event
+          ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+          : 'wheelDelta' in event
+            ? -event.wheelDelta
+            : 0
     },
     deltaZ: 0,
     // Browsers without "deltaMode" is reporting in raw wheel delta where one
     // notch on the scroll is always +/- 120, roughly equivalent to pixels.
     // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
     // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
-    deltaMode: 0
-  });
+    deltaMode: 0,
+  })
 
-  var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+  var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface)
 
   /**
    * HTML nodeType values that represent the type of the node
    */
-  var ELEMENT_NODE = 1;
+  var ELEMENT_NODE = 1
 
   function invokeGuardedCallbackProd(name, func, context, a, b, c, d, e, f) {
-    var funcArgs = Array.prototype.slice.call(arguments, 3);
+    var funcArgs = Array.prototype.slice.call(arguments, 3)
 
     try {
-      func.apply(context, funcArgs);
+      func.apply(context, funcArgs)
     } catch (error) {
-      this.onError(error);
+      this.onError(error)
     }
   }
 
-  var invokeGuardedCallbackImpl = invokeGuardedCallbackProd;
+  var invokeGuardedCallbackImpl = invokeGuardedCallbackProd
 
   {
     // In DEV mode, we swap out invokeGuardedCallback for a special version
@@ -898,60 +923,82 @@
     // try-catch. Neat!
     // Check that the browser supports the APIs we need to implement our special
     // DEV version of invokeGuardedCallback
-    if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {
-      var fakeNode = document.createElement('react');
-
-      invokeGuardedCallbackImpl = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
+    if (
+      typeof window !== 'undefined' &&
+      typeof window.dispatchEvent === 'function' &&
+      typeof document !== 'undefined' &&
+      typeof document.createEvent === 'function'
+    ) {
+      var fakeNode = document.createElement('react')
+
+      invokeGuardedCallbackImpl = function invokeGuardedCallbackDev(
+        name,
+        func,
+        context,
+        a,
+        b,
+        c,
+        d,
+        e,
+        f
+      ) {
         // If document doesn't exist we know for sure we will crash in this method
         // when we call document.createEvent(). However this can cause confusing
         // errors: https://github.com/facebook/create-react-app/issues/3482
         // So we preemptively throw with a better message instead.
         if (typeof document === 'undefined' || document === null) {
-          throw new Error('The `document` global was defined when React was initialized, but is not ' + 'defined anymore. This can happen in a test environment if a component ' + 'schedules an update from an asynchronous callback, but the test has already ' + 'finished running. To solve this, you can either unmount the component at ' + 'the end of your test (and ensure that any asynchronous operations get ' + 'canceled in `componentWillUnmount`), or you can change the test itself ' + 'to be asynchronous.');
+          throw new Error(
+            'The `document` global was defined when React was initialized, but is not ' +
+              'defined anymore. This can happen in a test environment if a component ' +
+              'schedules an update from an asynchronous callback, but the test has already ' +
+              'finished running. To solve this, you can either unmount the component at ' +
+              'the end of your test (and ensure that any asynchronous operations get ' +
+              'canceled in `componentWillUnmount`), or you can change the test itself ' +
+              'to be asynchronous.'
+          )
         }
 
-        var evt = document.createEvent('Event');
-        var didCall = false; // Keeps track of whether the user-provided callback threw an error. We
+        var evt = document.createEvent('Event')
+        var didCall = false // Keeps track of whether the user-provided callback threw an error. We
         // set this to true at the beginning, then set it to false right after
         // calling the function. If the function errors, `didError` will never be
         // set to false. This strategy works even if the browser is flaky and
         // fails to call our global error handler, because it doesn't rely on
         // the error event at all.
 
-        var didError = true; // Keeps track of the value of window.event so that we can reset it
+        var didError = true // Keeps track of the value of window.event so that we can reset it
         // during the callback to let user code access window.event in the
         // browsers that support it.
 
-        var windowEvent = window.event; // Keeps track of the descriptor of window.event to restore it after event
+        var windowEvent = window.event // Keeps track of the descriptor of window.event to restore it after event
         // dispatching: https://github.com/facebook/react/issues/13688
 
-        var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, 'event');
+        var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, 'event')
 
         function restoreAfterDispatch() {
           // We immediately remove the callback from event listeners so that
           // nested `invokeGuardedCallback` calls do not clash. Otherwise, a
           // nested call would trigger the fake event handlers of any call higher
           // in the stack.
-          fakeNode.removeEventListener(evtType, callCallback, false); // We check for window.hasOwnProperty('event') to prevent the
+          fakeNode.removeEventListener(evtType, callCallback, false) // We check for window.hasOwnProperty('event') to prevent the
           // window.event assignment in both IE <= 10 as they throw an error
           // "Member not found" in strict mode, and in Firefox which does not
           // support window.event.
 
           if (typeof window.event !== 'undefined' && window.hasOwnProperty('event')) {
-            window.event = windowEvent;
+            window.event = windowEvent
           }
         } // Create an event handler for our fake event. We will synchronously
         // dispatch our fake event using `dispatchEvent`. Inside the handler, we
         // call the user-provided callback.
 
-
-        var funcArgs = Array.prototype.slice.call(arguments, 3);
+        var funcArgs = Array.prototype.slice.call(arguments, 3)
 
         function callCallback() {
-          didCall = true;
-          restoreAfterDispatch();
-          func.apply(context, funcArgs);
-          didError = false;
+          didCall = true
+          restoreAfterDispatch()
+          func.apply(context, funcArgs)
+          didError = false
         } // Create a global error event handler. We use this to capture the value
         // that was thrown. It's possible that this error handler will fire more
         // than once; for example, if non-React code also calls `dispatchEvent`
@@ -964,18 +1011,17 @@
         // the callback doesn't error, but the error event was fired, we know to
         // ignore it because `didError` will be false, as described above.
 
+        var error // Use this to track whether the error event is ever called.
 
-        var error; // Use this to track whether the error event is ever called.
-
-        var didSetError = false;
-        var isCrossOriginError = false;
+        var didSetError = false
+        var isCrossOriginError = false
 
         function handleWindowError(event) {
-          error = event.error;
-          didSetError = true;
+          error = event.error
+          didSetError = true
 
           if (error === null && event.colno === 0 && event.lineno === 0) {
-            isCrossOriginError = true;
+            isCrossOriginError = true
           }
 
           if (event.defaultPrevented) {
@@ -984,68 +1030,80 @@
             // We'll remember this to later decide whether to log it or not.
             if (error != null && typeof error === 'object') {
               try {
-                error._suppressLogging = true;
-              } catch (inner) {// Ignore.
+                error._suppressLogging = true
+              } catch (inner) {
+                // Ignore.
               }
             }
           }
         } // Create a fake event type.
 
+        var evtType = 'react-' + (name ? name : 'invokeguardedcallback') // Attach our event handlers
 
-        var evtType = "react-" + (name ? name : 'invokeguardedcallback'); // Attach our event handlers
-
-        window.addEventListener('error', handleWindowError);
-        fakeNode.addEventListener(evtType, callCallback, false); // Synchronously dispatch our fake event. If the user-provided function
+        window.addEventListener('error', handleWindowError)
+        fakeNode.addEventListener(evtType, callCallback, false) // Synchronously dispatch our fake event. If the user-provided function
         // errors, it will trigger our global error handler.
 
-        evt.initEvent(evtType, false, false);
-        fakeNode.dispatchEvent(evt);
+        evt.initEvent(evtType, false, false)
+        fakeNode.dispatchEvent(evt)
 
         if (windowEventDescriptor) {
-          Object.defineProperty(window, 'event', windowEventDescriptor);
+          Object.defineProperty(window, 'event', windowEventDescriptor)
         }
 
         if (didCall && didError) {
           if (!didSetError) {
             // The callback errored, but the error event never fired.
             // eslint-disable-next-line react-internal/prod-error-codes
-            error = new Error('An error was thrown inside one of your components, but React ' + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.');
+            error = new Error(
+              'An error was thrown inside one of your components, but React ' +
+                "doesn't know what it was. This is likely due to browser " +
+                'flakiness. React does its best to preserve the "Pause on ' +
+                'exceptions" behavior of the DevTools, which requires some ' +
+                "DEV-mode only tricks. It's possible that these don't work in " +
+                'your browser. Try triggering the error in production mode, ' +
+                'or switching to a modern browser. If you suspect that this is ' +
+                'actually an issue with React, please file an issue.'
+            )
           } else if (isCrossOriginError) {
             // eslint-disable-next-line react-internal/prod-error-codes
-            error = new Error("A cross-origin error was thrown. React doesn't have access to " + 'the actual error object in development. ' + 'See https://reactjs.org/link/crossorigin-error for more information.');
+            error = new Error(
+              "A cross-origin error was thrown. React doesn't have access to " +
+                'the actual error object in development. ' +
+                'See https://reactjs.org/link/crossorigin-error for more information.'
+            )
           }
 
-          this.onError(error);
+          this.onError(error)
         } // Remove our event listeners
 
-
-        window.removeEventListener('error', handleWindowError);
+        window.removeEventListener('error', handleWindowError)
 
         if (!didCall) {
           // Something went really wrong, and our event was not dispatched.
           // https://github.com/facebook/react/issues/16734
           // https://github.com/facebook/react/issues/16585
           // Fall back to the production implementation.
-          restoreAfterDispatch();
-          return invokeGuardedCallbackProd.apply(this, arguments);
+          restoreAfterDispatch()
+          return invokeGuardedCallbackProd.apply(this, arguments)
         }
-      };
+      }
     }
   }
 
-  var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
+  var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl
 
-  var hasError = false;
-  var caughtError = null; // Used by event system to capture/rethrow the first error.
+  var hasError = false
+  var caughtError = null // Used by event system to capture/rethrow the first error.
 
-  var hasRethrowError = false;
-  var rethrowError = null;
+  var hasRethrowError = false
+  var rethrowError = null
   var reporter = {
     onError: function (error) {
-      hasError = true;
-      caughtError = error;
-    }
-  };
+      hasError = true
+      caughtError = error
+    },
+  }
   /**
    * Call a function while guarding against errors that happens within it.
    * Returns an error if it throws, otherwise null.
@@ -1061,9 +1119,9 @@
    */
 
   function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-    hasError = false;
-    caughtError = null;
-    invokeGuardedCallbackImpl$1.apply(reporter, arguments);
+    hasError = false
+    caughtError = null
+    invokeGuardedCallbackImpl$1.apply(reporter, arguments)
   }
   /**
    * Same as invokeGuardedCallback, but instead of returning an error, it stores
@@ -1076,15 +1134,25 @@
    * @param {...*} args Arguments for function
    */
 
-  function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
-    invokeGuardedCallback.apply(this, arguments);
+  function invokeGuardedCallbackAndCatchFirstError(
+    name,
+    func,
+    context,
+    a,
+    b,
+    c,
+    d,
+    e,
+    f
+  ) {
+    invokeGuardedCallback.apply(this, arguments)
 
     if (hasError) {
-      var error = clearCaughtError();
+      var error = clearCaughtError()
 
       if (!hasRethrowError) {
-        hasRethrowError = true;
-        rethrowError = error;
+        hasRethrowError = true
+        rethrowError = error
       }
     }
   }
@@ -1095,116 +1163,128 @@
 
   function rethrowCaughtError() {
     if (hasRethrowError) {
-      var error = rethrowError;
-      hasRethrowError = false;
-      rethrowError = null;
-      throw error;
+      var error = rethrowError
+      hasRethrowError = false
+      rethrowError = null
+      throw error
     }
   }
   function clearCaughtError() {
     if (hasError) {
-      var error = caughtError;
-      hasError = false;
-      caughtError = null;
-      return error;
+      var error = caughtError
+      hasError = false
+      caughtError = null
+      return error
     } else {
-      throw new Error('clearCaughtError was called but no error was captured. This error ' + 'is likely caused by a bug in React. Please file an issue.');
+      throw new Error(
+        'clearCaughtError was called but no error was captured. This error ' +
+          'is likely caused by a bug in React. Please file an issue.'
+      )
     }
   }
 
-  var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+  var isArrayImpl = Array.isArray // eslint-disable-next-line no-redeclare
 
   function isArray(a) {
-    return isArrayImpl(a);
+    return isArrayImpl(a)
   }
 
-  var SecretInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-  var EventInternals = SecretInternals.Events;
-  var getInstanceFromNode = EventInternals[0];
-  var getNodeFromInstance = EventInternals[1];
-  var getFiberCurrentPropsFromNode = EventInternals[2];
-  var enqueueStateRestore = EventInternals[3];
-  var restoreStateIfNeeded = EventInternals[4];
-  var reactAct = React.unstable_act;
+  var SecretInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+  var EventInternals = SecretInternals.Events
+  var getInstanceFromNode = EventInternals[0]
+  var getNodeFromInstance = EventInternals[1]
+  var getFiberCurrentPropsFromNode = EventInternals[2]
+  var enqueueStateRestore = EventInternals[3]
+  var restoreStateIfNeeded = EventInternals[4]
+  var reactAct = React.unstable_act
 
   function Event(suffix) {}
 
-  var hasWarnedAboutDeprecatedMockComponent = false;
+  var hasWarnedAboutDeprecatedMockComponent = false
   /**
    * @class ReactTestUtils
    */
 
   function findAllInRenderedFiberTreeInternal(fiber, test) {
     if (!fiber) {
-      return [];
+      return []
     }
 
-    var currentParent = findCurrentFiberUsingSlowPath(fiber);
+    var currentParent = findCurrentFiberUsingSlowPath(fiber)
 
     if (!currentParent) {
-      return [];
+      return []
     }
 
-    var node = currentParent;
-    var ret = [];
+    var node = currentParent
+    var ret = []
 
     while (true) {
-      if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent) {
-        var publicInst = node.stateNode;
+      if (
+        node.tag === HostComponent ||
+        node.tag === HostText ||
+        node.tag === ClassComponent ||
+        node.tag === FunctionComponent
+      ) {
+        var publicInst = node.stateNode
 
         if (test(publicInst)) {
-          ret.push(publicInst);
+          ret.push(publicInst)
         }
       }
 
       if (node.child) {
-        node.child.return = node;
-        node = node.child;
-        continue;
+        node.child.return = node
+        node = node.child
+        continue
       }
 
       if (node === currentParent) {
-        return ret;
+        return ret
       }
 
       while (!node.sibling) {
         if (!node.return || node.return === currentParent) {
-          return ret;
+          return ret
         }
 
-        node = node.return;
+        node = node.return
       }
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+      node.sibling.return = node.return
+      node = node.sibling
     }
   }
 
   function validateClassInstance(inst, methodName) {
     if (!inst) {
       // This is probably too relaxed but it's existing behavior.
-      return;
+      return
     }
 
     if (get(inst)) {
       // This is a public instance indeed.
-      return;
+      return
     }
 
-    var received;
-    var stringified = String(inst);
+    var received
+    var stringified = String(inst)
 
     if (isArray(inst)) {
-      received = 'an array';
+      received = 'an array'
     } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
-      received = 'a DOM node';
+      received = 'a DOM node'
     } else if (stringified === '[object Object]') {
-      received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
+      received = 'object with keys {' + Object.keys(inst).join(', ') + '}'
     } else {
-      received = stringified;
+      received = stringified
     }
 
-    throw new Error(methodName + "(...): the first argument must be a React class instance. " + ("Instead received: " + received + "."));
+    throw new Error(
+      methodName +
+        '(...): the first argument must be a React class instance. ' +
+        ('Instead received: ' + received + '.')
+    )
   }
   /**
    * Utilities for making it easy to test React components.
@@ -1216,72 +1296,81 @@
    * @lends ReactTestUtils
    */
 
-
-  var didWarnAboutReactTestUtilsDeprecation = false;
+  var didWarnAboutReactTestUtilsDeprecation = false
 
   function renderIntoDocument(element) {
     {
       if (!didWarnAboutReactTestUtilsDeprecation) {
-        didWarnAboutReactTestUtilsDeprecation = true;
-
-        error('ReactDOMTestUtils is deprecated and will be removed in a future ' + 'major release, because it exposes internal implementation details ' + 'that are highly likely to change between releases. Upgrade to a ' + 'modern testing library, such as @testing-library/react. See ' + 'https://react.dev/warnings/react-dom-test-utils for more info.');
+        didWarnAboutReactTestUtilsDeprecation = true
+
+        error(
+          'ReactDOMTestUtils is deprecated and will be removed in a future ' +
+            'major release, because it exposes internal implementation details ' +
+            'that are highly likely to change between releases. Upgrade to a ' +
+            'modern testing library, such as @testing-library/react. See ' +
+            'https://react.dev/warnings/react-dom-test-utils for more info.'
+        )
       }
     }
 
-    var div = document.createElement('div'); // None of our tests actually require attaching the container to the
+    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);
+    return ReactDOM.render(element, div)
   }
 
   function isElement(element) {
-    return React.isValidElement(element);
+    return React.isValidElement(element)
   }
 
   function isElementOfType(inst, convenienceConstructor) {
-    return React.isValidElement(inst) && inst.type === convenienceConstructor;
+    return React.isValidElement(inst) && inst.type === convenienceConstructor
   }
 
   function isDOMComponent(inst) {
-    return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
+    return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName)
   }
 
   function isDOMComponentElement(inst) {
-    return !!(inst && React.isValidElement(inst) && !!inst.tagName);
+    return !!(inst && React.isValidElement(inst) && !!inst.tagName)
   }
 
   function isCompositeComponent(inst) {
     if (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;
+      return false
     }
 
-    return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
+    return (
+      inst != null &&
+      typeof inst.render === 'function' &&
+      typeof inst.setState === 'function'
+    )
   }
 
   function isCompositeComponentWithType(inst, type) {
     if (!isCompositeComponent(inst)) {
-      return false;
+      return false
     }
 
-    var internalInstance = get(inst);
-    var constructor = internalInstance.type;
-    return constructor === type;
+    var internalInstance = get(inst)
+    var constructor = internalInstance.type
+    return constructor === type
   }
 
   function findAllInRenderedTree(inst, test) {
-    validateClassInstance(inst, 'findAllInRenderedTree');
+    validateClassInstance(inst, 'findAllInRenderedTree')
 
     if (!inst) {
-      return [];
+      return []
     }
 
-    var internalInstance = get(inst);
-    return findAllInRenderedFiberTreeInternal(internalInstance, test);
+    var internalInstance = get(inst)
+    return findAllInRenderedFiberTreeInternal(internalInstance, test)
   }
   /**
    * Finds all instances of components in the rendered tree that are DOM
@@ -1289,35 +1378,37 @@
    * @return {array} an array of all the matches.
    */
 
-
   function scryRenderedDOMComponentsWithClass(root, classNames) {
-    validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
+    validateClassInstance(root, 'scryRenderedDOMComponentsWithClass')
     return findAllInRenderedTree(root, function (inst) {
       if (isDOMComponent(inst)) {
-        var className = inst.className;
+        var className = inst.className
 
         if (typeof className !== 'string') {
           // SVG, probably.
-          className = inst.getAttribute('class') || '';
+          className = inst.getAttribute('class') || ''
         }
 
-        var classList = className.split(/\s+/);
+        var classList = className.split(/\s+/)
 
         if (!isArray(classNames)) {
           if (classNames === undefined) {
-            throw new Error('TestUtils.scryRenderedDOMComponentsWithClass expects a ' + 'className as a second argument.');
+            throw new 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 classList.indexOf(name) !== -1
+        })
       }
 
-      return false;
-    });
+      return false
+    })
   }
   /**
    * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
@@ -1326,16 +1417,21 @@
    * @return {!ReactDOMComponent} The one match.
    */
 
-
   function findRenderedDOMComponentWithClass(root, className) {
-    validateClassInstance(root, 'findRenderedDOMComponentWithClass');
-    var all = scryRenderedDOMComponentsWithClass(root, className);
+    validateClassInstance(root, 'findRenderedDOMComponentWithClass')
+    var all = scryRenderedDOMComponentsWithClass(root, className)
 
     if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
+      throw new Error(
+        'Did not find exactly one match (found: ' +
+          all.length +
+          ') ' +
+          'for class:' +
+          className
+      )
     }
 
-    return all[0];
+    return all[0]
   }
   /**
    * Finds all instances of components in the rendered tree that are DOM
@@ -1343,12 +1439,11 @@
    * @return {array} an array of all the matches.
    */
 
-
   function scryRenderedDOMComponentsWithTag(root, tagName) {
-    validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
+    validateClassInstance(root, 'scryRenderedDOMComponentsWithTag')
     return findAllInRenderedTree(root, function (inst) {
-      return isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
-    });
+      return isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase()
+    })
   }
   /**
    * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
@@ -1357,28 +1452,32 @@
    * @return {!ReactDOMComponent} The one match.
    */
 
-
   function findRenderedDOMComponentWithTag(root, tagName) {
-    validateClassInstance(root, 'findRenderedDOMComponentWithTag');
-    var all = scryRenderedDOMComponentsWithTag(root, tagName);
+    validateClassInstance(root, 'findRenderedDOMComponentWithTag')
+    var all = scryRenderedDOMComponentsWithTag(root, tagName)
 
     if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
+      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.
    */
 
-
   function scryRenderedComponentsWithType(root, componentType) {
-    validateClassInstance(root, 'scryRenderedComponentsWithType');
+    validateClassInstance(root, 'scryRenderedComponentsWithType')
     return findAllInRenderedTree(root, function (inst) {
-      return isCompositeComponentWithType(inst, componentType);
-    });
+      return isCompositeComponentWithType(inst, componentType)
+    })
   }
   /**
    * Same as `scryRenderedComponentsWithType` but expects there to be one result
@@ -1387,16 +1486,21 @@
    * @return {!ReactComponent} The one match.
    */
 
-
   function findRenderedComponentWithType(root, componentType) {
-    validateClassInstance(root, 'findRenderedComponentWithType');
-    var all = scryRenderedComponentsWithType(root, componentType);
+    validateClassInstance(root, 'findRenderedComponentWithType')
+    var all = scryRenderedComponentsWithType(root, componentType)
 
     if (all.length !== 1) {
-      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
+      throw new Error(
+        'Did not find exactly one match (found: ' +
+          all.length +
+          ') ' +
+          'for componentType:' +
+          componentType
+      )
     }
 
-    return all[0];
+    return all[0]
   }
   /**
    * Pass a mocked component module to this method to augment it with
@@ -1412,30 +1516,35 @@
    * @return {object} the ReactTestUtils object (for chaining)
    */
 
-
   function mockComponent(module, mockTagName) {
     {
       if (!hasWarnedAboutDeprecatedMockComponent) {
-        hasWarnedAboutDeprecatedMockComponent = true;
+        hasWarnedAboutDeprecatedMockComponent = true
 
-        warn('ReactTestUtils.mockComponent() is deprecated. ' + 'Use shallow rendering or jest.mock() instead.\n\n' + 'See https://reactjs.org/link/test-utils-mock-component for more information.');
+        warn(
+          'ReactTestUtils.mockComponent() is deprecated. ' +
+            'Use shallow rendering or jest.mock() instead.\n\n' +
+            'See https://reactjs.org/link/test-utils-mock-component for more information.'
+        )
       }
     }
 
-    mockTagName = mockTagName || module.mockTagName || 'div';
+    mockTagName = mockTagName || module.mockTagName || 'div'
     module.prototype.render.mockImplementation(function () {
-      return React.createElement(mockTagName, null, this.props.children);
-    });
-    return this;
+      return React.createElement(mockTagName, null, this.props.children)
+    })
+    return this
   }
 
   function nativeTouchData(x, y) {
     return {
-      touches: [{
-        pageX: x,
-        pageY: y
-      }]
-    };
+      touches: [
+        {
+          pageX: x,
+          pageY: y,
+        },
+      ],
+    }
   } // Start of inline: the below functions were inlined from
   // EventPropagator.js, as they deviated from ReactDOM's newer
   // implementations.
@@ -1447,37 +1556,34 @@
    * @param {*} inst Internal component instance
    */
 
-
   function executeDispatch(event, listener, inst) {
-    var type = event.type || 'unknown-event';
-    event.currentTarget = getNodeFromInstance(inst);
-    invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
-    event.currentTarget = null;
+    var type = event.type || 'unknown-event'
+    event.currentTarget = getNodeFromInstance(inst)
+    invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event)
+    event.currentTarget = null
   }
   /**
    * Standard/simple iteration through an event's collected dispatches.
    */
 
-
   function executeDispatchesInOrder(event) {
-    var dispatchListeners = event._dispatchListeners;
-    var dispatchInstances = event._dispatchInstances;
+    var dispatchListeners = event._dispatchListeners
+    var dispatchInstances = event._dispatchInstances
 
     if (isArray(dispatchListeners)) {
       for (var i = 0; i < dispatchListeners.length; i++) {
         if (event.isPropagationStopped()) {
-          break;
+          break
         } // Listeners and Instances are two parallel arrays that are always in sync.
 
-
-        executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+        executeDispatch(event, dispatchListeners[i], dispatchInstances[i])
       }
     } else if (dispatchListeners) {
-      executeDispatch(event, dispatchListeners, dispatchInstances);
+      executeDispatch(event, dispatchListeners, dispatchInstances)
     }
 
-    event._dispatchListeners = null;
-    event._dispatchInstances = null;
+    event._dispatchListeners = null
+    event._dispatchInstances = null
   }
   /**
    * Dispatches an event and releases it back into the pool, unless persistent.
@@ -1486,57 +1592,55 @@
    * @private
    */
 
-
   var executeDispatchesAndRelease = function (event) {
     if (event) {
-      executeDispatchesInOrder(event);
+      executeDispatchesInOrder(event)
 
       if (!event.isPersistent()) {
-        event.constructor.release(event);
+        event.constructor.release(event)
       }
     }
-  };
+  }
 
   function isInteractive(tag) {
-    return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+    return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea'
   }
 
   function getParent(inst) {
     do {
-      inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+      inst = inst.return // TODO: If this is a HostRoot we might want to bail out.
       // That is depending on if we want nested subtrees (layers) to bubble
       // events to their parent. We could also go through parentNode on the
       // host node but that wouldn't work for React Native and doesn't let us
       // do the portal feature.
-    } while (inst && inst.tag !== HostComponent);
+    } while (inst && inst.tag !== HostComponent)
 
     if (inst) {
-      return inst;
+      return inst
     }
 
-    return null;
+    return null
   }
   /**
    * Simulates the traversal of a two-phase, capture/bubble event dispatch.
    */
 
-
   function traverseTwoPhase(inst, fn, arg) {
-    var path = [];
+    var path = []
 
     while (inst) {
-      path.push(inst);
-      inst = getParent(inst);
+      path.push(inst)
+      inst = getParent(inst)
     }
 
-    var i;
+    var i
 
-    for (i = path.length; i-- > 0;) {
-      fn(path[i], 'captured', arg);
+    for (i = path.length; i-- > 0; ) {
+      fn(path[i], 'captured', arg)
     }
 
     for (i = 0; i < path.length; i++) {
-      fn(path[i], 'bubbled', arg);
+      fn(path[i], 'bubbled', arg)
     }
   }
 
@@ -1553,10 +1657,10 @@
       case 'onMouseUp':
       case 'onMouseUpCapture':
       case 'onMouseEnter':
-        return !!(props.disabled && isInteractive(type));
+        return !!(props.disabled && isInteractive(type))
 
       default:
-        return false;
+        return false
     }
   }
   /**
@@ -1565,64 +1669,69 @@
    * @return {?function} The stored callback.
    */
 
-
   function getListener(inst, registrationName) {
     // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
     // live here; needs to be moved to a better place soon
-    var stateNode = inst.stateNode;
+    var stateNode = inst.stateNode
 
     if (!stateNode) {
       // Work in progress (ex: onload events in incremental mode).
-      return null;
+      return null
     }
 
-    var props = getFiberCurrentPropsFromNode(stateNode);
+    var props = getFiberCurrentPropsFromNode(stateNode)
 
     if (!props) {
       // Work in progress.
-      return null;
+      return null
     }
 
-    var listener = props[registrationName];
+    var listener = props[registrationName]
 
     if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
-      return null;
+      return null
     }
 
     if (listener && typeof listener !== 'function') {
-      throw new Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type.");
+      throw new Error(
+        'Expected `' +
+          registrationName +
+          '` listener to be a function, instead got a value of `' +
+          typeof listener +
+          '` type.'
+      )
     }
 
-    return listener;
+    return listener
   }
 
   function listenerAtPhase(inst, event, propagationPhase) {
-    var registrationName = event._reactName;
+    var registrationName = event._reactName
 
     if (propagationPhase === 'captured') {
-      registrationName += 'Capture';
+      registrationName += 'Capture'
     }
 
-    return getListener(inst, registrationName);
+    return getListener(inst, registrationName)
   }
 
   function accumulateDispatches(inst, ignoredDirection, event) {
     if (inst && event && event._reactName) {
-      var registrationName = event._reactName;
-      var listener = getListener(inst, registrationName);
+      var registrationName = event._reactName
+      var listener = getListener(inst, registrationName)
 
       if (listener) {
         if (event._dispatchListeners == null) {
-          event._dispatchListeners = [];
+          event._dispatchListeners = []
         }
 
         if (event._dispatchInstances == null) {
-          event._dispatchInstances = [];
+          event._dispatchInstances = []
         }
 
-        event._dispatchListeners.push(listener);
+        event._dispatchListeners.push(listener)
 
-        event._dispatchInstances.push(inst);
+        event._dispatchInstances.push(inst)
       }
     }
   }
@@ -1630,42 +1739,46 @@
   function accumulateDirectionalDispatches(inst, phase, event) {
     {
       if (!inst) {
-        error('Dispatching inst must not be null');
+        error('Dispatching inst must not be null')
       }
     }
 
-    var listener = listenerAtPhase(inst, event, phase);
+    var listener = listenerAtPhase(inst, event, phase)
 
     if (listener) {
       if (event._dispatchListeners == null) {
-        event._dispatchListeners = [];
+        event._dispatchListeners = []
       }
 
       if (event._dispatchInstances == null) {
-        event._dispatchInstances = [];
+        event._dispatchInstances = []
       }
 
-      event._dispatchListeners.push(listener);
+      event._dispatchListeners.push(listener)
 
-      event._dispatchInstances.push(inst);
+      event._dispatchInstances.push(inst)
     }
   }
 
   function accumulateDirectDispatchesSingle(event) {
     if (event && event._reactName) {
-      accumulateDispatches(event._targetInst, null, event);
+      accumulateDispatches(event._targetInst, null, event)
     }
   }
 
   function accumulateTwoPhaseDispatchesSingle(event) {
     if (event && event._reactName) {
-      traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+      traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event)
     }
   } // End of inline
 
-
-  var Simulate = {};
-  var directDispatchEventTypes = new Set(['mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave']);
+  var Simulate = {}
+  var directDispatchEventTypes = new Set([
+    'mouseEnter',
+    'mouseLeave',
+    'pointerEnter',
+    'pointerLeave',
+  ])
   /**
    * Exports:
    *
@@ -1678,82 +1791,183 @@
   function makeSimulator(eventType) {
     return function (domNode, eventData) {
       if (React.isValidElement(domNode)) {
-        throw new 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 new 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.'
+        )
       }
 
       if (isCompositeComponent(domNode)) {
-        throw new 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 new 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 reactName = 'on' + eventType[0].toUpperCase() + eventType.slice(1);
-      var fakeNativeEvent = new Event();
-      fakeNativeEvent.target = domNode;
-      fakeNativeEvent.type = eventType.toLowerCase();
-      var targetInst = getInstanceFromNode(domNode);
-      var event = new SyntheticEvent(reactName, fakeNativeEvent.type, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
+      var reactName = 'on' + eventType[0].toUpperCase() + eventType.slice(1)
+      var fakeNativeEvent = new Event()
+      fakeNativeEvent.target = domNode
+      fakeNativeEvent.type = eventType.toLowerCase()
+      var targetInst = getInstanceFromNode(domNode)
+      var event = new SyntheticEvent(
+        reactName,
+        fakeNativeEvent.type,
+        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.
 
-      event.persist();
-      assign(event, eventData);
+      event.persist()
+      assign(event, eventData)
 
       if (directDispatchEventTypes.has(eventType)) {
-        accumulateDirectDispatchesSingle(event);
+        accumulateDirectDispatchesSingle(event)
       } else {
-        accumulateTwoPhaseDispatchesSingle(event);
+        accumulateTwoPhaseDispatchesSingle(event)
       }
 
       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);
-        executeDispatchesAndRelease(event);
-        rethrowCaughtError();
-      });
-      restoreStateIfNeeded();
-    };
+        enqueueStateRestore(domNode)
+        executeDispatchesAndRelease(event)
+        rethrowCaughtError()
+      })
+      restoreStateIfNeeded()
+    }
   } // A one-time snapshot with no plans to update. We'll probably want to deprecate Simulate API.
 
-
-  var simulatedEventTypes = ['blur', 'cancel', 'click', 'close', 'contextMenu', 'copy', 'cut', 'auxClick', 'doubleClick', 'dragEnd', 'dragStart', 'drop', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'mouseDown', 'mouseUp', 'paste', 'pause', 'play', 'pointerCancel', 'pointerDown', 'pointerUp', 'rateChange', 'reset', 'resize', 'seeked', 'submit', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'drag', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'mouseMove', 'mouseOut', 'mouseOver', 'pointerMove', 'pointerOut', 'pointerOver', 'scroll', 'toggle', 'touchMove', 'wheel', 'abort', 'animationEnd', 'animationIteration', 'animationStart', 'canPlay', 'canPlayThrough', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'playing', 'progress', 'seeking', 'stalled', 'suspend', 'timeUpdate', 'transitionEnd', 'waiting', 'mouseEnter', 'mouseLeave', 'pointerEnter', 'pointerLeave', 'change', 'select', 'beforeInput', 'compositionEnd', 'compositionStart', 'compositionUpdate'];
+  var simulatedEventTypes = [
+    'blur',
+    'cancel',
+    'click',
+    'close',
+    'contextMenu',
+    'copy',
+    'cut',
+    'auxClick',
+    'doubleClick',
+    'dragEnd',
+    'dragStart',
+    'drop',
+    'focus',
+    'input',
+    'invalid',
+    'keyDown',
+    'keyPress',
+    'keyUp',
+    'mouseDown',
+    'mouseUp',
+    'paste',
+    'pause',
+    'play',
+    'pointerCancel',
+    'pointerDown',
+    'pointerUp',
+    'rateChange',
+    'reset',
+    'resize',
+    'seeked',
+    'submit',
+    'touchCancel',
+    'touchEnd',
+    'touchStart',
+    'volumeChange',
+    'drag',
+    'dragEnter',
+    'dragExit',
+    'dragLeave',
+    'dragOver',
+    'mouseMove',
+    'mouseOut',
+    'mouseOver',
+    'pointerMove',
+    'pointerOut',
+    'pointerOver',
+    'scroll',
+    'toggle',
+    'touchMove',
+    'wheel',
+    'abort',
+    'animationEnd',
+    'animationIteration',
+    'animationStart',
+    'canPlay',
+    'canPlayThrough',
+    'durationChange',
+    'emptied',
+    'encrypted',
+    'ended',
+    'error',
+    'gotPointerCapture',
+    'load',
+    'loadedData',
+    'loadedMetadata',
+    'loadStart',
+    'lostPointerCapture',
+    'playing',
+    'progress',
+    'seeking',
+    'stalled',
+    'suspend',
+    'timeUpdate',
+    'transitionEnd',
+    'waiting',
+    'mouseEnter',
+    'mouseLeave',
+    'pointerEnter',
+    'pointerLeave',
+    'change',
+    'select',
+    'beforeInput',
+    'compositionEnd',
+    'compositionStart',
+    'compositionUpdate',
+  ]
 
   function buildSimulators() {
     simulatedEventTypes.forEach(function (eventType) {
-      Simulate[eventType] = makeSimulator(eventType);
-    });
+      Simulate[eventType] = makeSimulator(eventType)
+    })
   }
 
-  buildSimulators();
-  var didWarnAboutUsingAct = false;
-  var act =  function actWithWarning(callback) {
+  buildSimulators()
+  var didWarnAboutUsingAct = false
+  var act = function actWithWarning(callback) {
     {
       if (!didWarnAboutUsingAct) {
-        didWarnAboutUsingAct = true;
+        didWarnAboutUsingAct = true
 
-        error('`ReactDOMTestUtils.act` is deprecated in favor of `React.act`. ' + 'Import `act` from `react` instead of `react-dom/test-utils`. ' + 'See https://react.dev/warnings/react-dom-test-utils for more info.');
+        error(
+          '`ReactDOMTestUtils.act` is deprecated in favor of `React.act`. ' +
+            'Import `act` from `react` instead of `react-dom/test-utils`. ' +
+            'See https://react.dev/warnings/react-dom-test-utils for more info.'
+        )
       }
     }
 
-    return reactAct(callback);
-  } ;
-
-  exports.Simulate = Simulate;
-  exports.act = act;
-  exports.findAllInRenderedTree = findAllInRenderedTree;
-  exports.findRenderedComponentWithType = findRenderedComponentWithType;
-  exports.findRenderedDOMComponentWithClass = findRenderedDOMComponentWithClass;
-  exports.findRenderedDOMComponentWithTag = findRenderedDOMComponentWithTag;
-  exports.isCompositeComponent = isCompositeComponent;
-  exports.isCompositeComponentWithType = isCompositeComponentWithType;
-  exports.isDOMComponent = isDOMComponent;
-  exports.isDOMComponentElement = isDOMComponentElement;
-  exports.isElement = isElement;
-  exports.isElementOfType = isElementOfType;
-  exports.mockComponent = mockComponent;
-  exports.nativeTouchData = nativeTouchData;
-  exports.renderIntoDocument = renderIntoDocument;
-  exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType;
-  exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
-  exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
-  exports.traverseTwoPhase = traverseTwoPhase;
-
-})));
+    return reactAct(callback)
+  }
+
+  exports.Simulate = Simulate
+  exports.act = act
+  exports.findAllInRenderedTree = findAllInRenderedTree
+  exports.findRenderedComponentWithType = findRenderedComponentWithType
+  exports.findRenderedDOMComponentWithClass = findRenderedDOMComponentWithClass
+  exports.findRenderedDOMComponentWithTag = findRenderedDOMComponentWithTag
+  exports.isCompositeComponent = isCompositeComponent
+  exports.isCompositeComponentWithType = isCompositeComponentWithType
+  exports.isDOMComponent = isDOMComponent
+  exports.isDOMComponentElement = isDOMComponentElement
+  exports.isElement = isElement
+  exports.isElementOfType = isElementOfType
+  exports.mockComponent = mockComponent
+  exports.nativeTouchData = nativeTouchData
+  exports.renderIntoDocument = renderIntoDocument
+  exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType
+  exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass
+  exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag
+  exports.traverseTwoPhase = traverseTwoPhase
+})