@coinbase/cdp-core 0.0.120 → 0.0.121

package/dist/web/index.web226.js

@@ -1,23 +1,855 @@
-import { JOSENotSupported as f } from "./index.web128.js";
-const w = (n, r, a, e, s) => {
-  if (s.crit !== void 0 && e?.crit === void 0)
-    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
-  if (!e || e.crit === void 0)
-    return /* @__PURE__ */ new Set();
-  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
-    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  let t;
-  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
-  for (const i of e.crit) {
-    if (!t.has(i))
-      throw new f(`Extension Header Parameter "${i}" is not recognized`);
-    if (s[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" is missing`);
-    if (t.get(i) && e[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
-  }
-  return new Set(e.crit);
-};
+import { __module as E } from "./index.web247.js";
+E.exports;
+var we;
+function Ye() {
+  return we ? E.exports : (we = 1, (function(P, u) {
+    process.env.NODE_ENV !== "production" && (function() {
+      function Ee(e, t) {
+        Object.defineProperty(h.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              t[0],
+              t[1]
+            );
+          }
+        });
+      }
+      function be(e) {
+        return e === null || typeof e != "object" ? null : (e = ae && e[ae] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function N(e, t) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var r = e + "." + t;
+        se[r] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          t,
+          e
+        ), se[r] = !0);
+      }
+      function h(e, t, r) {
+        this.props = e, this.context = t, this.refs = G, this.updater = r || ie;
+      }
+      function B() {
+      }
+      function M(e, t, r) {
+        this.props = e, this.context = t, this.refs = G, this.updater = r || ie;
+      }
+      function L() {
+      }
+      function K(e) {
+        return "" + e;
+      }
+      function b(e) {
+        try {
+          K(e);
+          var t = !1;
+        } catch {
+          t = !0;
+        }
+        if (t) {
+          t = console;
+          var r = t.error, n = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return r.call(
+            t,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            n
+          ), K(e);
+        }
+      }
+      function T(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === je ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case q:
+            return "Fragment";
+          case te:
+            return "Profiler";
+          case ee:
+            return "StrictMode";
+          case oe:
+            return "Suspense";
+          case Ce:
+            return "SuspenseList";
+          case ue:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case x:
+              return "Portal";
+            case re:
+              return e.displayName || "Context";
+            case z:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case ne:
+              var t = e.render;
+              return e = e.displayName, e || (e = t.displayName || t.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case H:
+              return t = e.displayName || null, t !== null ? t : T(e.type) || "Memo";
+            case v:
+              t = e._payload, e = e._init;
+              try {
+                return T(e(t));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function F(e) {
+        if (e === q) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === v)
+          return "<...>";
+        try {
+          var t = T(e);
+          return t ? "<" + t + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function X() {
+        var e = s.A;
+        return e === null ? null : e.getOwner();
+      }
+      function V() {
+        return Error("react-stack-top-frame");
+      }
+      function Z(e) {
+        if (S.call(e, "key")) {
+          var t = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (t && t.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function Te(e, t) {
+        function r() {
+          de || (de = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            t
+          ));
+        }
+        r.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: r,
+          configurable: !0
+        });
+      }
+      function Re() {
+        var e = T(this.type);
+        return he[e] || (he[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function D(e, t, r, n, o, i) {
+        var a = r.ref;
+        return e = {
+          $$typeof: W,
+          type: e,
+          key: t,
+          props: r,
+          _owner: n
+        }, (a !== void 0 ? a : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: Re
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: o
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: i
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function Oe(e, t) {
+        return t = D(
+          e.type,
+          t,
+          e.props,
+          e._owner,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (t._store.validated = e._store.validated), t;
+      }
+      function J(e) {
+        m(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === v && (e._payload.status === "fulfilled" ? m(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+      }
+      function m(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === W;
+      }
+      function ke(e) {
+        var t = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(r) {
+          return t[r];
+        });
+      }
+      function Y(e, t) {
+        return typeof e == "object" && e !== null && e.key != null ? (b(e.key), ke("" + e.key)) : t.toString(36);
+      }
+      function Se(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(L, L) : (e.status = "pending", e.then(
+              function(t) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = t);
+              },
+              function(t) {
+                e.status === "pending" && (e.status = "rejected", e.reason = t);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function y(e, t, r, n, o) {
+        var i = typeof e;
+        (i === "undefined" || i === "boolean") && (e = null);
+        var a = !1;
+        if (e === null) a = !0;
+        else
+          switch (i) {
+            case "bigint":
+            case "string":
+            case "number":
+              a = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case W:
+                case x:
+                  a = !0;
+                  break;
+                case v:
+                  return a = e._init, y(
+                    a(e._payload),
+                    t,
+                    r,
+                    n,
+                    o
+                  );
+              }
+          }
+        if (a) {
+          a = e, o = o(a);
+          var f = n === "" ? "." + Y(a, 0) : n;
+          return fe(o) ? (r = "", f != null && (r = f.replace(ye, "$&/") + "/"), y(o, t, r, "", function(p) {
+            return p;
+          })) : o != null && (m(o) && (o.key != null && (a && a.key === o.key || b(o.key)), r = Oe(
+            o,
+            r + (o.key == null || a && a.key === o.key ? "" : ("" + o.key).replace(
+              ye,
+              "$&/"
+            ) + "/") + f
+          ), n !== "" && a != null && m(a) && a.key == null && a._store && !a._store.validated && (r._store.validated = 2), o = r), t.push(o)), 1;
+        }
+        if (a = 0, f = n === "" ? "." : n + ":", fe(e))
+          for (var c = 0; c < e.length; c++)
+            n = e[c], i = f + Y(n, c), a += y(
+              n,
+              t,
+              r,
+              i,
+              o
+            );
+        else if (c = be(e), typeof c == "function")
+          for (c === e.entries && (me || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), me = !0), e = c.call(e), c = 0; !(n = e.next()).done; )
+            n = n.value, i = f + Y(n, c++), a += y(
+              n,
+              t,
+              r,
+              i,
+              o
+            );
+        else if (i === "object") {
+          if (typeof e.then == "function")
+            return y(
+              Se(e),
+              t,
+              r,
+              n,
+              o
+            );
+          throw t = String(e), Error(
+            "Objects are not valid as a React child (found: " + (t === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : t) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return a;
+      }
+      function R(e, t, r) {
+        if (e == null) return e;
+        var n = [], o = 0;
+        return y(e, n, "", "", function(i) {
+          return t.call(r, i, o++);
+        }), n;
+      }
+      function Ae(e) {
+        if (e._status === -1) {
+          var t = e._ioInfo;
+          t != null && (t.start = t.end = performance.now()), t = e._result;
+          var r = t();
+          if (r.then(
+            function(o) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 1, e._result = o;
+                var i = e._ioInfo;
+                i != null && (i.end = performance.now()), r.status === void 0 && (r.status = "fulfilled", r.value = o);
+              }
+            },
+            function(o) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 2, e._result = o;
+                var i = e._ioInfo;
+                i != null && (i.end = performance.now()), r.status === void 0 && (r.status = "rejected", r.reason = o);
+              }
+            }
+          ), t = e._ioInfo, t != null) {
+            t.value = r;
+            var n = r.displayName;
+            typeof n == "string" && (t.name = n);
+          }
+          e._status === -1 && (e._status = 0, e._result = r);
+        }
+        if (e._status === 1)
+          return t = e._result, t === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            t
+          ), "default" in t || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            t
+          ), t.default;
+        throw e._result;
+      }
+      function l() {
+        var e = s.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function $() {
+        s.asyncTransitions--;
+      }
+      function O(e) {
+        if (A === null)
+          try {
+            var t = ("require" + Math.random()).slice(0, 7);
+            A = (P && P[t]).call(
+              P,
+              "timers"
+            ).setImmediate;
+          } catch {
+            A = function(n) {
+              ge === !1 && (ge = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var o = new MessageChannel();
+              o.port1.onmessage = n, o.port2.postMessage(void 0);
+            };
+          }
+        return A(e);
+      }
+      function g(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function k(e, t) {
+        t !== C - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), C = t;
+      }
+      function U(e, t, r) {
+        var n = s.actQueue;
+        if (n !== null)
+          if (n.length !== 0)
+            try {
+              I(n), O(function() {
+                return U(e, t, r);
+              });
+              return;
+            } catch (o) {
+              s.thrownErrors.push(o);
+            }
+          else s.actQueue = null;
+        0 < s.thrownErrors.length ? (n = g(s.thrownErrors), s.thrownErrors.length = 0, r(n)) : t(e);
+      }
+      function I(e) {
+        if (!Q) {
+          Q = !0;
+          var t = 0;
+          try {
+            for (; t < e.length; t++) {
+              var r = e[t];
+              do {
+                s.didUsePromise = !1;
+                var n = r(!1);
+                if (n !== null) {
+                  if (s.didUsePromise) {
+                    e[t] = r, e.splice(0, t);
+                    return;
+                  }
+                  r = n;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (o) {
+            e.splice(0, t + 1), s.thrownErrors.push(o);
+          } finally {
+            Q = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var W = /* @__PURE__ */ Symbol.for("react.transitional.element"), x = /* @__PURE__ */ Symbol.for("react.portal"), q = /* @__PURE__ */ Symbol.for("react.fragment"), ee = /* @__PURE__ */ Symbol.for("react.strict_mode"), te = /* @__PURE__ */ Symbol.for("react.profiler"), z = /* @__PURE__ */ Symbol.for("react.consumer"), re = /* @__PURE__ */ Symbol.for("react.context"), ne = /* @__PURE__ */ Symbol.for("react.forward_ref"), oe = /* @__PURE__ */ Symbol.for("react.suspense"), Ce = /* @__PURE__ */ Symbol.for("react.suspense_list"), H = /* @__PURE__ */ Symbol.for("react.memo"), v = /* @__PURE__ */ Symbol.for("react.lazy"), ue = /* @__PURE__ */ Symbol.for("react.activity"), ae = Symbol.iterator, se = {}, ie = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          N(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          N(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          N(e, "setState");
+        }
+      }, ce = Object.assign, G = {};
+      Object.freeze(G), h.prototype.isReactComponent = {}, h.prototype.setState = function(e, t) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, t, "setState");
+      }, h.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var d = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (w in d)
+        d.hasOwnProperty(w) && Ee(w, d[w]);
+      B.prototype = h.prototype, d = M.prototype = new B(), d.constructor = M, ce(d, h.prototype), d.isPureReactComponent = !0;
+      var fe = Array.isArray, je = /* @__PURE__ */ Symbol.for("react.client.reference"), s = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, S = Object.prototype.hasOwnProperty, le = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      d = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var de, pe, he = {}, Pe = d.react_stack_bottom_frame.bind(
+        d,
+        V
+      )(), Ne = le(F(V)), me = !1, ye = /\/+/g, _e = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var t = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(t)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, ge = !1, A = null, C = 0, j = !1, Q = !1, ve = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : O;
+      d = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return l().useMemoCache(e);
+        }
+      });
+      var w = {
+        map: R,
+        forEach: function(e, t, r) {
+          R(
+            e,
+            function() {
+              t.apply(this, arguments);
+            },
+            r
+          );
+        },
+        count: function(e) {
+          var t = 0;
+          return R(e, function() {
+            t++;
+          }), t;
+        },
+        toArray: function(e) {
+          return R(e, function(t) {
+            return t;
+          }) || [];
+        },
+        only: function(e) {
+          if (!m(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      };
+      u.Activity = ue, u.Children = w, u.Component = h, u.Fragment = q, u.Profiler = te, u.PureComponent = M, u.StrictMode = ee, u.Suspense = oe, u.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = s, u.__COMPILER_RUNTIME = d, u.act = function(e) {
+        var t = s.actQueue, r = C;
+        C++;
+        var n = s.actQueue = t !== null ? t : [], o = !1;
+        try {
+          var i = e();
+        } catch (c) {
+          s.thrownErrors.push(c);
+        }
+        if (0 < s.thrownErrors.length)
+          throw k(t, r), e = g(s.thrownErrors), s.thrownErrors.length = 0, e;
+        if (i !== null && typeof i == "object" && typeof i.then == "function") {
+          var a = i;
+          return ve(function() {
+            o || j || (j = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(c, p) {
+              o = !0, a.then(
+                function(_) {
+                  if (k(t, r), r === 0) {
+                    try {
+                      I(n), O(function() {
+                        return U(
+                          _,
+                          c,
+                          p
+                        );
+                      });
+                    } catch (Le) {
+                      s.thrownErrors.push(Le);
+                    }
+                    if (0 < s.thrownErrors.length) {
+                      var Me = g(
+                        s.thrownErrors
+                      );
+                      s.thrownErrors.length = 0, p(Me);
+                    }
+                  } else c(_);
+                },
+                function(_) {
+                  k(t, r), 0 < s.thrownErrors.length && (_ = g(
+                    s.thrownErrors
+                  ), s.thrownErrors.length = 0), p(_);
+                }
+              );
+            }
+          };
+        }
+        var f = i;
+        if (k(t, r), r === 0 && (I(n), n.length !== 0 && ve(function() {
+          o || j || (j = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), s.actQueue = null), 0 < s.thrownErrors.length)
+          throw e = g(s.thrownErrors), s.thrownErrors.length = 0, e;
+        return {
+          then: function(c, p) {
+            o = !0, r === 0 ? (s.actQueue = n, O(function() {
+              return U(
+                f,
+                c,
+                p
+              );
+            })) : c(f);
+          }
+        };
+      }, u.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, u.cacheSignal = function() {
+        return null;
+      }, u.captureOwnerStack = function() {
+        var e = s.getCurrentStack;
+        return e === null ? null : e();
+      }, u.cloneElement = function(e, t, r) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var n = ce({}, e.props), o = e.key, i = e._owner;
+        if (t != null) {
+          var a;
+          e: {
+            if (S.call(t, "ref") && (a = Object.getOwnPropertyDescriptor(
+              t,
+              "ref"
+            ).get) && a.isReactWarning) {
+              a = !1;
+              break e;
+            }
+            a = t.ref !== void 0;
+          }
+          a && (i = X()), Z(t) && (b(t.key), o = "" + t.key);
+          for (f in t)
+            !S.call(t, f) || f === "key" || f === "__self" || f === "__source" || f === "ref" && t.ref === void 0 || (n[f] = t[f]);
+        }
+        var f = arguments.length - 2;
+        if (f === 1) n.children = r;
+        else if (1 < f) {
+          a = Array(f);
+          for (var c = 0; c < f; c++)
+            a[c] = arguments[c + 2];
+          n.children = a;
+        }
+        for (n = D(
+          e.type,
+          o,
+          n,
+          i,
+          e._debugStack,
+          e._debugTask
+        ), o = 2; o < arguments.length; o++)
+          J(arguments[o]);
+        return n;
+      }, u.createContext = function(e) {
+        return e = {
+          $$typeof: re,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: z,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, u.createElement = function(e, t, r) {
+        for (var n = 2; n < arguments.length; n++)
+          J(arguments[n]);
+        n = {};
+        var o = null;
+        if (t != null)
+          for (c in pe || !("__self" in t) || "key" in t || (pe = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), Z(t) && (b(t.key), o = "" + t.key), t)
+            S.call(t, c) && c !== "key" && c !== "__self" && c !== "__source" && (n[c] = t[c]);
+        var i = arguments.length - 2;
+        if (i === 1) n.children = r;
+        else if (1 < i) {
+          for (var a = Array(i), f = 0; f < i; f++)
+            a[f] = arguments[f + 2];
+          Object.freeze && Object.freeze(a), n.children = a;
+        }
+        if (e && e.defaultProps)
+          for (c in i = e.defaultProps, i)
+            n[c] === void 0 && (n[c] = i[c]);
+        o && Te(
+          n,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var c = 1e4 > s.recentlyCreatedOwnerStacks++;
+        return D(
+          e,
+          o,
+          n,
+          X(),
+          c ? Error("react-stack-top-frame") : Pe,
+          c ? le(F(e)) : Ne
+        );
+      }, u.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, u.forwardRef = function(e) {
+        e != null && e.$$typeof === H ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var t = { $$typeof: ne, render: e }, r;
+        return Object.defineProperty(t, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return r;
+          },
+          set: function(n) {
+            r = n, e.name || e.displayName || (Object.defineProperty(e, "name", { value: n }), e.displayName = n);
+          }
+        }), t;
+      }, u.isValidElement = m, u.lazy = function(e) {
+        e = { _status: -1, _result: e };
+        var t = {
+          $$typeof: v,
+          _payload: e,
+          _init: Ae
+        }, r = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        return e._ioInfo = r, t._debugInfo = [{ awaited: r }], t;
+      }, u.memo = function(e, t) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), t = {
+          $$typeof: H,
+          type: e,
+          compare: t === void 0 ? null : t
+        };
+        var r;
+        return Object.defineProperty(t, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return r;
+          },
+          set: function(n) {
+            r = n, e.name || e.displayName || (Object.defineProperty(e, "name", { value: n }), e.displayName = n);
+          }
+        }), t;
+      }, u.startTransition = function(e) {
+        var t = s.T, r = {};
+        r._updatedFibers = /* @__PURE__ */ new Set(), s.T = r;
+        try {
+          var n = e(), o = s.S;
+          o !== null && o(r, n), typeof n == "object" && n !== null && typeof n.then == "function" && (s.asyncTransitions++, n.then($, $), n.then(L, _e));
+        } catch (i) {
+          _e(i);
+        } finally {
+          t === null && r._updatedFibers && (e = r._updatedFibers.size, r._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), t !== null && r.types !== null && (t.types !== null && t.types !== r.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), t.types = r.types), s.T = t;
+        }
+      }, u.unstable_useCacheRefresh = function() {
+        return l().useCacheRefresh();
+      }, u.use = function(e) {
+        return l().use(e);
+      }, u.useActionState = function(e, t, r) {
+        return l().useActionState(
+          e,
+          t,
+          r
+        );
+      }, u.useCallback = function(e, t) {
+        return l().useCallback(e, t);
+      }, u.useContext = function(e) {
+        var t = l();
+        return e.$$typeof === z && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), t.useContext(e);
+      }, u.useDebugValue = function(e, t) {
+        return l().useDebugValue(e, t);
+      }, u.useDeferredValue = function(e, t) {
+        return l().useDeferredValue(e, t);
+      }, u.useEffect = function(e, t) {
+        return e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), l().useEffect(e, t);
+      }, u.useEffectEvent = function(e) {
+        return l().useEffectEvent(e);
+      }, u.useId = function() {
+        return l().useId();
+      }, u.useImperativeHandle = function(e, t, r) {
+        return l().useImperativeHandle(e, t, r);
+      }, u.useInsertionEffect = function(e, t) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), l().useInsertionEffect(e, t);
+      }, u.useLayoutEffect = function(e, t) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), l().useLayoutEffect(e, t);
+      }, u.useMemo = function(e, t) {
+        return l().useMemo(e, t);
+      }, u.useOptimistic = function(e, t) {
+        return l().useOptimistic(e, t);
+      }, u.useReducer = function(e, t, r) {
+        return l().useReducer(e, t, r);
+      }, u.useRef = function(e) {
+        return l().useRef(e);
+      }, u.useState = function(e) {
+        return l().useState(e);
+      }, u.useSyncExternalStore = function(e, t, r) {
+        return l().useSyncExternalStore(
+          e,
+          t,
+          r
+        );
+      }, u.useTransition = function() {
+        return l().useTransition();
+      }, u.version = "19.2.7", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  })(E, E.exports), E.exports);
+}
 export {
-  w as default
+  Ye as __require
 };