@boxcustodia/library 0.3.8 → 0.5.1

package/dist/index.es192.js

@@ -1,4 +1,725 @@
-var r = {};
+import { __exports as s } from "./index.es273.js";
+import Ot from "react";
+import Pt from "react-dom";
+/**
+ * @license React
+ * react-dom-test-utils.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ve;
+function At() {
+  return ve ? s : (ve = 1, process.env.NODE_ENV !== "production" && function() {
+    var m = Ot, S = Pt, N = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function ye(e) {
+      {
+        for (var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++)
+          r[n - 1] = arguments[n];
+        j("warn", e, r);
+      }
+    }
+    function O(e) {
+      {
+        for (var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++)
+          r[n - 1] = arguments[n];
+        j("error", e, r);
+      }
+    }
+    function j(e, t, r) {
+      {
+        var n = N.ReactDebugCurrentFrame, a = n.getStackAddendum();
+        a !== "" && (t += "%s", r = r.concat([a]));
+        var o = r.map(function(i) {
+          return String(i);
+        });
+        o.unshift("Warning: " + t), Function.prototype.apply.call(console[e], console, o);
+      }
+    }
+    function P(e) {
+      return e._reactInternals;
+    }
+    var ge = 0, we = 1, V = 3, G = 5, Ee = 6, Ce = (
+      /*                      */
+      0
+    ), be = (
+      /*                    */
+      2
+    ), De = (
+      /*                    */
+      4096
+    );
+    N.ReactCurrentOwner;
+    function q(e) {
+      var t = e, r = e;
+      if (e.alternate)
+        for (; t.return; )
+          t = t.return;
+      else {
+        var n = t;
+        do
+          t = n, (t.flags & (be | De)) !== Ce && (r = t.return), n = t.return;
+        while (n);
+      }
+      return t.tag === V ? r : null;
+    }
+    function H(e) {
+      if (q(e) !== e)
+        throw new Error("Unable to find node on an unmounted component.");
+    }
+    function Te(e) {
+      var t = e.alternate;
+      if (!t) {
+        var r = q(e);
+        if (r === null)
+          throw new Error("Unable to find node on an unmounted component.");
+        return r !== e ? null : e;
+      }
+      for (var n = e, a = t; ; ) {
+        var o = n.return;
+        if (o === null)
+          break;
+        var i = o.alternate;
+        if (i === null) {
+          var d = o.return;
+          if (d !== null) {
+            n = a = d;
+            continue;
+          }
+          break;
+        }
+        if (o.child === i.child) {
+          for (var p = o.child; p; ) {
+            if (p === n)
+              return H(o), e;
+            if (p === a)
+              return H(o), t;
+            p = p.sibling;
+          }
+          throw new Error("Unable to find node on an unmounted component.");
+        }
+        if (n.return !== a.return)
+          n = o, a = i;
+        else {
+          for (var f = !1, u = o.child; u; ) {
+            if (u === n) {
+              f = !0, n = o, a = i;
+              break;
+            }
+            if (u === a) {
+              f = !0, a = o, n = i;
+              break;
+            }
+            u = u.sibling;
+          }
+          if (!f) {
+            for (u = i.child; u; ) {
+              if (u === n) {
+                f = !0, n = i, a = o;
+                break;
+              }
+              if (u === a) {
+                f = !0, a = i, n = o;
+                break;
+              }
+              u = u.sibling;
+            }
+            if (!f)
+              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 (n.alternate !== a)
+          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 (n.tag !== V)
+        throw new Error("Unable to find node on an unmounted component.");
+      return n.stateNode.current === n ? e : t;
+    }
+    var c = Object.assign;
+    function U(e) {
+      var t, r = e.keyCode;
+      return "charCode" in e ? (t = e.charCode, t === 0 && r === 13 && (t = 13)) : t = r, t === 10 && (t = 13), t >= 32 || t === 13 ? t : 0;
+    }
+    function b() {
+      return !0;
+    }
+    function z() {
+      return !1;
+    }
+    function l(e) {
+      function t(r, n, a, o, i) {
+        this._reactName = r, this._targetInst = a, this.type = n, this.nativeEvent = o, this.target = i, this.currentTarget = null;
+        for (var d in e)
+          if (e.hasOwnProperty(d)) {
+            var p = e[d];
+            p ? this[d] = p(o) : this[d] = o[d];
+          }
+        var f = o.defaultPrevented != null ? o.defaultPrevented : o.returnValue === !1;
+        return f ? this.isDefaultPrevented = b : this.isDefaultPrevented = z, this.isPropagationStopped = z, this;
+      }
+      return c(t.prototype, {
+        preventDefault: function() {
+          this.defaultPrevented = !0;
+          var r = this.nativeEvent;
+          r && (r.preventDefault ? r.preventDefault() : typeof r.returnValue != "unknown" && (r.returnValue = !1), this.isDefaultPrevented = b);
+        },
+        stopPropagation: function() {
+          var r = this.nativeEvent;
+          r && (r.stopPropagation ? r.stopPropagation() : typeof r.cancelBubble != "unknown" && (r.cancelBubble = !0), this.isPropagationStopped = b);
+        },
+        /**
+         * 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() {
+        },
+        /**
+         * Checks if this event should be released back into the pool.
+         *
+         * @return {boolean} True if this should not be released, false otherwise.
+         */
+        isPersistent: b
+      }), t;
+    }
+    var y = {
+      eventPhase: 0,
+      bubbles: 0,
+      cancelable: 0,
+      timeStamp: function(e) {
+        return e.timeStamp || Date.now();
+      },
+      defaultPrevented: 0,
+      isTrusted: 0
+    }, ke = l(y), g = c({}, y, {
+      view: 0,
+      detail: 0
+    });
+    l(g);
+    var _, L, w;
+    function Re(e) {
+      e !== w && (w && e.type === "mousemove" ? (_ = e.screenX - w.screenX, L = e.screenY - w.screenY) : (_ = 0, L = 0), w = e);
+    }
+    var D = c({}, g, {
+      screenX: 0,
+      screenY: 0,
+      clientX: 0,
+      clientY: 0,
+      pageX: 0,
+      pageY: 0,
+      ctrlKey: 0,
+      shiftKey: 0,
+      altKey: 0,
+      metaKey: 0,
+      getModifierState: W,
+      button: 0,
+      buttons: 0,
+      relatedTarget: function(e) {
+        return e.relatedTarget === void 0 ? e.fromElement === e.srcElement ? e.toElement : e.fromElement : e.relatedTarget;
+      },
+      movementX: function(e) {
+        return "movementX" in e ? e.movementX : (Re(e), _);
+      },
+      movementY: function(e) {
+        return "movementY" in e ? e.movementY : L;
+      }
+    });
+    l(D);
+    var Me = c({}, D, {
+      dataTransfer: 0
+    });
+    l(Me);
+    var Ie = c({}, g, {
+      relatedTarget: 0
+    });
+    l(Ie);
+    var Se = c({}, y, {
+      animationName: 0,
+      elapsedTime: 0,
+      pseudoElement: 0
+    });
+    l(Se);
+    var Oe = c({}, y, {
+      clipboardData: function(e) {
+        return "clipboardData" in e ? e.clipboardData : window.clipboardData;
+      }
+    });
+    l(Oe);
+    var Pe = c({}, y, {
+      data: 0
+    });
+    l(Pe);
+    var Ue = {
+      Esc: "Escape",
+      Spacebar: " ",
+      Left: "ArrowLeft",
+      Up: "ArrowUp",
+      Right: "ArrowRight",
+      Down: "ArrowDown",
+      Del: "Delete",
+      Win: "OS",
+      Menu: "ContextMenu",
+      Apps: "ContextMenu",
+      Scroll: "ScrollLock",
+      MozPrintableKey: "Unidentified"
+    }, _e = {
+      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"
+    };
+    function Le(e) {
+      if (e.key) {
+        var t = Ue[e.key] || e.key;
+        if (t !== "Unidentified")
+          return t;
+      }
+      if (e.type === "keypress") {
+        var r = U(e);
+        return r === 13 ? "Enter" : String.fromCharCode(r);
+      }
+      return e.type === "keydown" || e.type === "keyup" ? _e[e.keyCode] || "Unidentified" : "";
+    }
+    var We = {
+      Alt: "altKey",
+      Control: "ctrlKey",
+      Meta: "metaKey",
+      Shift: "shiftKey"
+    };
+    function Ae(e) {
+      var t = this, r = t.nativeEvent;
+      if (r.getModifierState)
+        return r.getModifierState(e);
+      var n = We[e];
+      return n ? !!r[n] : !1;
+    }
+    function W(e) {
+      return Ae;
+    }
+    var xe = c({}, g, {
+      key: Le,
+      code: 0,
+      location: 0,
+      ctrlKey: 0,
+      shiftKey: 0,
+      altKey: 0,
+      metaKey: 0,
+      repeat: 0,
+      locale: 0,
+      getModifierState: W,
+      // Legacy Interface
+      charCode: function(e) {
+        return e.type === "keypress" ? U(e) : 0;
+      },
+      keyCode: function(e) {
+        return e.type === "keydown" || e.type === "keyup" ? e.keyCode : 0;
+      },
+      which: function(e) {
+        return e.type === "keypress" ? U(e) : e.type === "keydown" || e.type === "keyup" ? e.keyCode : 0;
+      }
+    });
+    l(xe);
+    var Fe = c({}, D, {
+      pointerId: 0,
+      width: 0,
+      height: 0,
+      pressure: 0,
+      tangentialPressure: 0,
+      tiltX: 0,
+      tiltY: 0,
+      twist: 0,
+      pointerType: 0,
+      isPrimary: 0
+    });
+    l(Fe);
+    var Ke = c({}, g, {
+      touches: 0,
+      targetTouches: 0,
+      changedTouches: 0,
+      altKey: 0,
+      metaKey: 0,
+      ctrlKey: 0,
+      shiftKey: 0,
+      getModifierState: W
+    });
+    l(Ke);
+    var Ye = c({}, y, {
+      propertyName: 0,
+      elapsedTime: 0,
+      pseudoElement: 0
+    });
+    l(Ye);
+    var Xe = c({}, D, {
+      deltaX: function(e) {
+        return "deltaX" in e ? e.deltaX : (
+          // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+          "wheelDeltaX" in e ? -e.wheelDeltaX : 0
+        );
+      },
+      deltaY: function(e) {
+        return "deltaY" in e ? e.deltaY : (
+          // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+          "wheelDeltaY" in e ? -e.wheelDeltaY : (
+            // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+            "wheelDelta" in e ? -e.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
+    });
+    l(Xe);
+    var Z = 1;
+    function $(e, t, r, n, a, o, i, d, p) {
+      var f = Array.prototype.slice.call(arguments, 3);
+      try {
+        t.apply(r, f);
+      } catch (u) {
+        this.onError(u);
+      }
+    }
+    var J = $;
+    if (typeof window < "u" && typeof window.dispatchEvent == "function" && typeof document < "u" && typeof document.createEvent == "function") {
+      var A = document.createElement("react");
+      J = function(t, r, n, a, o, i, d, p, f) {
+        if (typeof document > "u" || 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.");
+        var u = document.createEvent("Event"), Y = !1, ce = !0, It = window.event, le = Object.getOwnPropertyDescriptor(window, "event");
+        function fe() {
+          A.removeEventListener(X, de, !1), typeof window.event < "u" && window.hasOwnProperty("event") && (window.event = It);
+        }
+        var St = Array.prototype.slice.call(arguments, 3);
+        function de() {
+          Y = !0, fe(), r.apply(n, St), ce = !1;
+        }
+        var h, pe = !1, he = !1;
+        function me(I) {
+          if (h = I.error, pe = !0, h === null && I.colno === 0 && I.lineno === 0 && (he = !0), I.defaultPrevented && h != null && typeof h == "object")
+            try {
+              h._suppressLogging = !0;
+            } catch {
+            }
+        }
+        var X = "react-" + (t || "invokeguardedcallback");
+        if (window.addEventListener("error", me), A.addEventListener(X, de, !1), u.initEvent(X, !1, !1), A.dispatchEvent(u), le && Object.defineProperty(window, "event", le), Y && ce && (pe ? he && (h = 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.")) : h = 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.`), this.onError(h)), window.removeEventListener("error", me), !Y)
+          return fe(), $.apply(this, arguments);
+      };
+    }
+    var Ne = J, E = !1, T = null, k = !1, x = null, je = {
+      onError: function(e) {
+        E = !0, T = e;
+      }
+    };
+    function Ve(e, t, r, n, a, o, i, d, p) {
+      E = !1, T = null, Ne.apply(je, arguments);
+    }
+    function Ge(e, t, r, n, a, o, i, d, p) {
+      if (Ve.apply(this, arguments), E) {
+        var f = He();
+        k || (k = !0, x = f);
+      }
+    }
+    function qe() {
+      if (k) {
+        var e = x;
+        throw k = !1, x = null, e;
+      }
+    }
+    function He() {
+      if (E) {
+        var e = T;
+        return E = !1, T = null, e;
+      } 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.");
+    }
+    var ze = Array.isArray;
+    function F(e) {
+      return ze(e);
+    }
+    var Ze = S.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, C = Ze.Events, $e = C[0], Je = C[1], Qe = C[2], Be = C[3], et = C[4], tt = m.unstable_act;
+    function rt(e) {
+    }
+    var Q = !1;
+    function nt(e, t) {
+      if (!e)
+        return [];
+      var r = Te(e);
+      if (!r)
+        return [];
+      for (var n = r, a = []; ; ) {
+        if (n.tag === G || n.tag === Ee || n.tag === we || n.tag === ge) {
+          var o = n.stateNode;
+          t(o) && a.push(o);
+        }
+        if (n.child) {
+          n.child.return = n, n = n.child;
+          continue;
+        }
+        if (n === r)
+          return a;
+        for (; !n.sibling; ) {
+          if (!n.return || n.return === r)
+            return a;
+          n = n.return;
+        }
+        n.sibling.return = n.return, n = n.sibling;
+      }
+    }
+    function v(e, t) {
+      if (e && !P(e)) {
+        var r, n = String(e);
+        throw F(e) ? r = "an array" : e && e.nodeType === Z && e.tagName ? r = "a DOM node" : n === "[object Object]" ? r = "object with keys {" + Object.keys(e).join(", ") + "}" : r = n, new Error(t + "(...): the first argument must be a React class instance. " + ("Instead received: " + r + "."));
+      }
+    }
+    var B = !1;
+    function at(e) {
+      B || (B = !0, O("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 t = document.createElement("div");
+      return S.render(e, t);
+    }
+    function ot(e) {
+      return m.isValidElement(e);
+    }
+    function it(e, t) {
+      return m.isValidElement(e) && e.type === t;
+    }
+    function R(e) {
+      return !!(e && e.nodeType === Z && e.tagName);
+    }
+    function st(e) {
+      return !!(e && m.isValidElement(e) && e.tagName);
+    }
+    function K(e) {
+      return R(e) ? !1 : e != null && typeof e.render == "function" && typeof e.setState == "function";
+    }
+    function ee(e, t) {
+      if (!K(e))
+        return !1;
+      var r = P(e), n = r.type;
+      return n === t;
+    }
+    function M(e, t) {
+      if (v(e, "findAllInRenderedTree"), !e)
+        return [];
+      var r = P(e);
+      return nt(r, t);
+    }
+    function te(e, t) {
+      return v(e, "scryRenderedDOMComponentsWithClass"), M(e, function(r) {
+        if (R(r)) {
+          var n = r.className;
+          typeof n != "string" && (n = r.getAttribute("class") || "");
+          var a = n.split(/\s+/);
+          if (!F(t)) {
+            if (t === void 0)
+              throw new Error("TestUtils.scryRenderedDOMComponentsWithClass expects a className as a second argument.");
+            t = t.split(/\s+/);
+          }
+          return t.every(function(o) {
+            return a.indexOf(o) !== -1;
+          });
+        }
+        return !1;
+      });
+    }
+    function ut(e, t) {
+      v(e, "findRenderedDOMComponentWithClass");
+      var r = te(e, t);
+      if (r.length !== 1)
+        throw new Error("Did not find exactly one match (found: " + r.length + ") for class:" + t);
+      return r[0];
+    }
+    function re(e, t) {
+      return v(e, "scryRenderedDOMComponentsWithTag"), M(e, function(r) {
+        return R(r) && r.tagName.toUpperCase() === t.toUpperCase();
+      });
+    }
+    function ct(e, t) {
+      v(e, "findRenderedDOMComponentWithTag");
+      var r = re(e, t);
+      if (r.length !== 1)
+        throw new Error("Did not find exactly one match (found: " + r.length + ") for tag:" + t);
+      return r[0];
+    }
+    function ne(e, t) {
+      return v(e, "scryRenderedComponentsWithType"), M(e, function(r) {
+        return ee(r, t);
+      });
+    }
+    function lt(e, t) {
+      v(e, "findRenderedComponentWithType");
+      var r = ne(e, t);
+      if (r.length !== 1)
+        throw new Error("Did not find exactly one match (found: " + r.length + ") for componentType:" + t);
+      return r[0];
+    }
+    function ft(e, t) {
+      return Q || (Q = !0, ye(`ReactTestUtils.mockComponent() is deprecated. Use shallow rendering or jest.mock() instead.
+
+See https://reactjs.org/link/test-utils-mock-component for more information.`)), t = t || e.mockTagName || "div", e.prototype.render.mockImplementation(function() {
+        return m.createElement(t, null, this.props.children);
+      }), this;
+    }
+    function dt(e, t) {
+      return {
+        touches: [{
+          pageX: e,
+          pageY: t
+        }]
+      };
+    }
+    function ae(e, t, r) {
+      var n = e.type || "unknown-event";
+      e.currentTarget = Je(r), Ge(n, t, void 0, e), e.currentTarget = null;
+    }
+    function pt(e) {
+      var t = e._dispatchListeners, r = e._dispatchInstances;
+      if (F(t))
+        for (var n = 0; n < t.length && !e.isPropagationStopped(); n++)
+          ae(e, t[n], r[n]);
+      else t && ae(e, t, r);
+      e._dispatchListeners = null, e._dispatchInstances = null;
+    }
+    var ht = function(e) {
+      e && (pt(e), e.isPersistent() || e.constructor.release(e));
+    };
+    function mt(e) {
+      return e === "button" || e === "input" || e === "select" || e === "textarea";
+    }
+    function vt(e) {
+      do
+        e = e.return;
+      while (e && e.tag !== G);
+      return e || null;
+    }
+    function oe(e, t, r) {
+      for (var n = []; e; )
+        n.push(e), e = vt(e);
+      var a;
+      for (a = n.length; a-- > 0; )
+        t(n[a], "captured", r);
+      for (a = 0; a < n.length; a++)
+        t(n[a], "bubbled", r);
+    }
+    function yt(e, t, r) {
+      switch (e) {
+        case "onClick":
+        case "onClickCapture":
+        case "onDoubleClick":
+        case "onDoubleClickCapture":
+        case "onMouseDown":
+        case "onMouseDownCapture":
+        case "onMouseMove":
+        case "onMouseMoveCapture":
+        case "onMouseUp":
+        case "onMouseUpCapture":
+        case "onMouseEnter":
+          return !!(r.disabled && mt(t));
+        default:
+          return !1;
+      }
+    }
+    function ie(e, t) {
+      var r = e.stateNode;
+      if (!r)
+        return null;
+      var n = Qe(r);
+      if (!n)
+        return null;
+      var a = n[t];
+      if (yt(t, e.type, n))
+        return null;
+      if (a && typeof a != "function")
+        throw new Error("Expected `" + t + "` listener to be a function, instead got a value of `" + typeof a + "` type.");
+      return a;
+    }
+    function gt(e, t, r) {
+      var n = t._reactName;
+      return r === "captured" && (n += "Capture"), ie(e, n);
+    }
+    function wt(e, t, r) {
+      if (e && r && r._reactName) {
+        var n = r._reactName, a = ie(e, n);
+        a && (r._dispatchListeners == null && (r._dispatchListeners = []), r._dispatchInstances == null && (r._dispatchInstances = []), r._dispatchListeners.push(a), r._dispatchInstances.push(e));
+      }
+    }
+    function Et(e, t, r) {
+      e || O("Dispatching inst must not be null");
+      var n = gt(e, r, t);
+      n && (r._dispatchListeners == null && (r._dispatchListeners = []), r._dispatchInstances == null && (r._dispatchInstances = []), r._dispatchListeners.push(n), r._dispatchInstances.push(e));
+    }
+    function Ct(e) {
+      e && e._reactName && wt(e._targetInst, null, e);
+    }
+    function bt(e) {
+      e && e._reactName && oe(e._targetInst, Et, e);
+    }
+    var se = {}, Dt = /* @__PURE__ */ new Set(["mouseEnter", "mouseLeave", "pointerEnter", "pointerLeave"]);
+    function Tt(e) {
+      return function(t, r) {
+        if (m.isValidElement(t))
+          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 (K(t))
+          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 n = "on" + e[0].toUpperCase() + e.slice(1), a = new rt();
+        a.target = t, a.type = e.toLowerCase();
+        var o = $e(t), i = new ke(n, a.type, o, a, t);
+        i.persist(), c(i, r), Dt.has(e) ? Ct(i) : bt(i), S.unstable_batchedUpdates(function() {
+          Be(t), ht(i), qe();
+        }), et();
+      };
+    }
+    var kt = ["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 Rt() {
+      kt.forEach(function(e) {
+        se[e] = Tt(e);
+      });
+    }
+    Rt();
+    var ue = !1, Mt = function(t) {
+      return ue || (ue = !0, O("`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.")), tt(t);
+    };
+    s.Simulate = se, s.act = Mt, s.findAllInRenderedTree = M, s.findRenderedComponentWithType = lt, s.findRenderedDOMComponentWithClass = ut, s.findRenderedDOMComponentWithTag = ct, s.isCompositeComponent = K, s.isCompositeComponentWithType = ee, s.isDOMComponent = R, s.isDOMComponentElement = st, s.isElement = ot, s.isElementOfType = it, s.mockComponent = ft, s.nativeTouchData = dt, s.renderIntoDocument = at, s.scryRenderedComponentsWithType = ne, s.scryRenderedDOMComponentsWithClass = te, s.scryRenderedDOMComponentsWithTag = re, s.traverseTwoPhase = oe;
+  }(), s);
+}
 export {
-  r as __exports
+  At as __require
 };